Architecture des ordinateurs

Gianluca QUERCINI
Enseignant-chercheur,
CentraleSupélec, Laboratoire de Recherche en Informatique, Univ.
Paris-Saclay
Département Informatique, Bureau D2.20

[Link]@[Link]

Séquence 0, 2017 - 2018

L’ordinateur
• Ordinateur : machine conçue pour faire des calculs.
– « Computer » en Anglais : personne qui fait des calculs.
– Le mot « computer » a été utilisé pour indiquer une machine qui fait des calculs à
partir de 1945 (ENIAC – Eckert et Mauchly).

• Mais aujourd’hui un ordinateur fait beaucoup plus que ça….

• Résoudre des problèmes suivant un programme.

– Programme : séquence d’instructions décrivant la façon dont le problème doit être
résolu.

• Deux catégories d’ordinateurs :

– Ordinateur personnel (personal computer ou PC).
– Système embarqué (embedded system).
• intégré dans un système afin de le contrôler et le piloter (lave-linges).

Architecture des ordinateurs 2

Objectifs du cours
Objectif principal : Démystifier l’ordinateur et ses composants.

• Analyser les principaux composants d’un ordinateur et leur rôle.

– Processeur, mémoire, périphériques….

• Décrire l’organisation et le fonctionnement de ces entités.

– Fonctionnement d’un processeur, de la mémoire…

• Comprendre l’exécution d’un programme.

– Comment le processeur comprend et exécute-t-il un programme Python?

Architecture des ordinateurs 3

 Les composants d’un ordinateur
Processeur = CPU
Mémoire
principale

Périphériques

Mémoire
secondaire Serial/USB/F
Serial/USB/F irewire
irewire

Réseau
input
Audio
output
Carte
graphique
Architecture des ordinateurs 4
Logiciel (Software)
Logiciels utilisés par les
utilisateurs.
Applications

Système Logiciel pour le contrôle de

l’ordinateur. Fournit une
d’exploitation interface aux utilisateurs.

Logiciel(s) pour la gestion et le

Firmware contrôle du matériel.

Matériel
(hardware)
Architecture des ordinateurs 5
 Architecture de l’ordinateur
Architecture de l’ordinateur : étude du fonctionnement des composants
internes d’un ordinateur.

• Fonctionnement logique interne des composants.

• Dialogue entre composants.

• Type des données manipulées et leur codage.

Architecture des ordinateurs 6

Organisation du cours
• 7 cours magistraux (CM).
– 1 CM = 1h30
– Présentation orale des concepts principaux du cours.

• 3 bureaux d’études (BE).

– 1 BE = 2 TD = 3h
– Travaux dirigés en salle machine.

• 2 études de laboratoire (EL).

– 1 EL = 3 TP = 4h30
– Travaux pratiques en salle machine.

Architecture des ordinateurs 7

Questions ?
• Pendant le cours.

• Après le cours.

• En dehors du cours :
– Département informatique, Bureau D2.20
– Courriel : [Link]@[Link]

• Site du cours : [Link]

Architecture des ordinateurs 8

 Programme
• Chapitre 1 : Circuits logiques (15/09/2017).
– Circuits combinatoires.
– Circuits séquentiels.

• Chapitre 2 : Arithmétique des processeurs (15/09/2017).

– Codage des entiers naturels et relatifs.
– Codage des nombres réels.
– Codage des caractères.

• Chapitre 3 : Le processeur (15/09/2017).

– Composants d’un processeur.
– Fonctionnement d’un processeur.

• Bureau d’étude 1 : Circuits combinatoires et séquentiels (19/09/2017)

Architecture des ordinateurs 9

 Programme
• Chapitre 4 : Langages de programmation (20/09/2017).
– Langages compilés et interprétés.
– Appel de fonction et notion de pile.
– Fonctions récursives.

• Chapitre 5 : Mémoire (20/09/2017).

– La mémoire RAM
– La mémoire secondaire.
– Notion de mémoire cache.

• Bureau d’étude 2 : Traduction d’instructions Python en langage

d’assemblage (20/09/2017).

Architecture des ordinateurs 10

 Programme
• Chapitre 6 : Entrées/Sorties (21/09/2017).
– Notion de bus.
– Entrées/Sorties mappées en mémoire.
– Notion d’interruption.

• Chapitre 7 : Notions avancées sur les processeurs (21/09/2017).

– Architectures RISC et CISC.
– Aperçu d’un processeur réel.

• Chapitre 8 : Aperçu de l’histoire de l’informatique (21/09/2017).

• Bureau d’étude 3 : MicroPython, entrées/sorties, interruptions (25/09/2017).

Architecture des ordinateurs 11

 Programme
• Etude de laboratoire 1 : Réalisation d’un microprocesseur.

• Etude de laboratoire 2 : Entrées/sorties.

Architecture des ordinateurs 12

CHAPITRE I
Circuits logiques

Architecture des ordinateurs

 Circuit logique
• Circuit électronique qui calcule une ou plusieurs fonctions logiques.

• Un circuit logique utilise deux valeurs logiques (bits – binary digits) :

– un signal entre 0V et 1V : bit 0.
– un signal entre 2V et 5V : bit 1.

• Les circuits logiques utilisent une arithmétique binaire.

– Bit (chiffre binaire): unité de mémoire de base
– 1 octet (byte) = 8 bits, 1 KB (Kilobyte) = 210 bytes = 1 024 octets
– 1 MB (Megabyte) = 220 bytes = 1 048 576 octets, 1 GB (Gigabyte) = 230 bytes
– 1 TB (Terabyte) = 1000 GB, 1 PB (Petabyte) = 1000 TB, 1 EB (Exabyte) = 1000 PB
– 1 ZB (Zettabyte) = 1000 EB, 1 YB (Yottabyte) = 1000 ZB
• Arithmétique hexadécimale pour rendre plus compacte la notation binaire.
– 16 chiffres : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F

Architecture des ordinateurs 14

Algèbre de Boole
• Les circuits logiques peuvent être décrits à l’aide de l’algèbre de Boole.
– opérations et fonctions sur des variables logiques qui ne peuvent prendre que les
valeurs 0 (faux) et 1 (vrai)
– George Boole (1815 - 1864) : mathématicien britannique.
• Fonction booléenne.
– Entrée : une ou plusieurs variables booléennes.
– Sortie : 0 ou 1.
– Décrite à l’aide d’une table de vérité.
• Fonctions booléennes de base.
– Soient A, B deux variables booléennes
– AND (A•B), OR (A+B), NOT (Ā), NAND (A•B), NOR (A+B), XOR (A⊕B)

A B Ā B̅ A•B A+B A•B A+B A⊕B

0 0 1 1 0 0 1 1 0
0 1 1 0 0 1 1 0 1
1 0 0 1 0 1 1 0 1
1 1 0 0 1 1 0 0 0
Architecture des ordinateurs 15
Portes logiques
• Porte logique : circuit logique de base.
– Réalisation des fonctions booléennes élémentaires (NOT, NAND, NOR, AND, OR, XOR).
– réalisée avec des transistors.

• Une porte logique peut avoir plusieurs entrées.

Architecture des ordinateurs 16

 Exemple de circuit logique
• Un circuit logique est un ensemble de portes logiques interconnectées.

• Deux types de circuits logiques : combinatoires et séquentiels.

Architecture des ordinateurs 17

Circuits logiques combinatoires
• Circuit combinatoire : la valeur des sorties ne dépend que de la valeur des
entrées.

• Les composants d’un ordinateur (par ex. un processeur) contiennent

beaucoup de circuits combinatoires :
– Additionneur : circuit pour additionner deux nombres.
– Multiplexeur : circuit qui redirige une de ses entrées vers la sortie.
– Démultiplexeur : circuit qui redirige une entrée vers une de ses sorties.
– Décodeur : active (met la valeur 1 sur) une des ses sorties selon un code en entrée.
– Codeur : pour une entrée active (valeur 1), fournit un code en sortie.

Architecture des ordinateurs 18

 L’additionneur à 1 bit
• Le composant de base est le demi-additionneur (half-adder).
• Réalise l’addition de deux nombres codés chacun sur un 1 bit.
• Deux entrées : A et B, 1 bit chacun.
• Deux sorties : Sum (somme) et Carry (retenue), 1 bit chacun.

Architecture des ordinateurs 19

 L’additionneur à 1 bit
• L’additionneur complet (full adder) :
– Réalise l’addition de deux nombres codés chacun sur un 1 bit.
– Prend aussi en compte une éventuelle retenue en entrée.
• Trois entrées : A, B, Cin (retenue en entrée), 1 bit chacun.
• Deux sorties : Sum (somme) et Cout (retenue en sortie), 1 bit chacun.
• Idée : mettre en série deux demi additionneurs.
– Un pour obtenir S = A + B.
– L’autre pour obtenir Sum = Cin + S.
– Problème : comment combiner les deux retenues produites par les deux demi
additionneurs pour obtenir Cout?

Architecture des ordinateurs 20

L’additionneur à n bits
• Idée : mettre en cascade n additionneurs complets à 1 bits.

Architecture des ordinateurs 21

 Unité Arithmétique Logique (UAL)
CUAL S

0000 A

A B 0001 B
8 8 0010 A+B

0011 A-B

0100 B-A
N
CUAL Z 0101 -A

4 0110 -B

0111 <<A

8 1000 <<B

1001 >>A
S
1010 >>B

Architecture des systèmes informatiques 22

Circuits séquentiels
• Circuit séquentiel : la valeur des sorties dépend de la valeur des entrées
actuelles et passées.

• Présence d’une boucle dans le circuit → circuit séquentiel.

• Notion de mémoire.

• Notion de temps (horloge).

Architecture des ordinateurs 23

Bistable
• Bistable : 2 valeurs stables dans le temps.

• Notion de mémorisation.

• Plusieurs façons de réaliser un bistable avec des bascules.

– Une bascule est un circuit séquentiel qui réalise une bistable.

Architecture des ordinateurs 24

Bascule RS

S R Q
0 0 val. précédente Mémorisation
0 1 0
1 0 1
1 1 (interdit)

Architecture des ordinateurs 25

Bascule RS synchrone
• Introduction de la notion d’horloge (clock).
– Horloge : signal périodique (1 demi-période à 0, l’autre à 1).
• Permet la lecture d’une valeur à un instant bien déterminé.
– pour faire face au délai de propagation dans un circuit logique.

• Problème : la configuration S = R = 1 devrait être interdite.

• Solution : bascule D.

Architecture des ordinateurs 26

Bascule D
Bascule D : mémoire de 1 bit.

Architecture des ordinateurs 27

Bascule D flip-flop
• Variante de la bascule D.
• La valeur en entrée est propagée à la sortie sur le front montant de l’horloge

Architecture des ordinateurs 28

Registres
• Registre : mémoire rapide utilisée dans les processeurs.

Bascule flip-flop

Registre 8 bits

Architecture des ordinateurs 29

 Logique à trois états
• La sortie des circuits logiques que nous avons vus peut avoir deux états :
– Etat 0 : niveau logique bas.
– Etat 1 : niveau logique haut.
• Il y a des circuits qui se basent sur une logique à trois états.
– Etat 0 : niveau logique bas.
– Etat 1 : niveau logique haut.
– Etat indéfini : haute impédance.

Utilisé pour connecter plusieurs

circuits au même fil.
Tampon trois états (tri-state buffer)
C
I O
C

Architecture des ordinateurs 30

CHAPITRE II
Arithmétique des processeurs

Architecture des ordinateurs

Arithmétique des processeurs
• Un processeur est composé de plusieurs circuits logiques.
– circuits combinatoires (par ex.: UAL).
– circuits séquentiels (registres).

• Un circuit logique utilise seulement deux valeurs : 0 et 1 (bits).

• Toute l’information manipulée par un processeur doit être codée en binaire.

– nombres entiers, réels, textes, images…

• Pour les entiers naturels : représentation binaire classique.

• Pour les autres types de données, besoin d’un codage.

Architecture des ordinateurs 32

 Entiers relatifs : 1) bit de signe
Notation pour un entier k
Exemple sur 3 bits
010 001
2 1
bit de signe |k|
0 si k ≥ 0 011 000
1 si k ≤ 0 3 0

100 111
0 -3
Problèmes : 101 110
– 2 représentations de 0
-1 -2
– addition et soustraction différentes de celles des entiers naturels

Architecture des ordinateurs 33

 Entiers relatifs : 2) complément à 1

Valeurs entre -2k-1 + 1 et 2k-1 - 1

bit de signe |k| Si k ≤ 0, les chiffres de |k|

0 si k ≥ 0 sont inversés
1 si k ≤ 0
Décimal Positif Négatif Problème avec la somme si les deux
0 0000 1111 opérandes ont signe négatif ou signe
1 0001 1110 différent mais résultat positif.
2 0010 1101
3 0011 1100 11001 + (-6)
4 0100 1011 11010 = (-5)
5 0101 1010 10011 (-12) résultat correct - 1
6 0110 1001
7 0111 1000

Architecture des ordinateurs 34

 Entiers relatifs : 2) complément à 2
Valeurs entre -2k-1 et 2k-1 - 1

bit de signe |k| Si k ≤ 0, les chiffres de |k| sont

0 si k ≥ 0 inversés et on ajoute 1
1 si k ≤ 0
Décimal Positif Négatif
0 0000 0000 Une seule représentation
pour le 0
1 0001 1111
2 0010 1110
3 0011 1101
4 0100 1100
5 0101 1011
6 0110 1010
7 0111 1001
8 - 1000

Architecture des ordinateurs 35

Précision finie
• Le processeur (l’UAL) manipule seulement des nombres ayant une taille de
représentation fixée : 1, 2, 4 ou 8 octets.
• Dans les langages de programmation, cela se traduit par des types ayant un
domaine fini → débordements (overflow) possibles.
• Exemple de débordement.
– Sur 8 bits en complément à deux, valeur maximale 127 (0111111).
– Qu’est-ce qu’il se passe quand on fait 120 + 8 ?
• 120 (01111000) + 8 (00001000) = -128 (10000000)!!

01111000 (120) +
00001000 (8) =
-----------------------------
10000000 (-128!)

Architecture des ordinateurs 36

Nombres en virgule fixe
• La présence d’une virgule ne change pas les algorithmes de calcul, il faut
simplement ajuster la position de la virgule dans le résultat.

• Exemple : sur un octet, virgule fixe avec 3 bits après la virgule.

1 octet

,
4 3 2 1 0 -1 -2 -3

1 0 0 1 0 1 0 1 18.625

24 + 21 = 18 2-1 + 2-3 = 0,625

Architecture des ordinateurs 37

Nombres en virgule flottante
• La représentation en virgule fixe ne permet pas de manipuler des très grands
nombres (ou de très petits).

• Ceux-ci sont pourtant nécessaires (physique par exemple).

• Représentation en virgule flottante dérivée de la

notation scientifique :

23
6,02 x 10
Mantisse Exposant
chiffres significatifs ordre de grandeur
(virgule fixe) (entier)
Architecture des ordinateurs 38
 IEEE 754 “binary32”

78
+ 1,9918509 x2 = 6,02 x 1023

Mantisse Exposant
1≤m<2 –126 ≤ e ≤ +127

78 + 127 = 205 (déc)

X
= 1,11111101111010011111000 (bin)

bit e + 127 “m”

de
signe pour avoir des valeurs positives le chiffre avant la virgule est toujours 1, donc inutile

0 1 1 0 0 1 1 0 1 1 1 1 1 1 1 0 1 1 1 1 0 1 0 0 1 1 1 1 1 0 0 0
1 8 23

Architecture des ordinateurs 39

Notions sur le codage de caractères

• Toute donnée informatique est vue comme une séquence (finie) d'octets, c-
à-d d'entiers entre 0 et 255 ($00 et $FF).

• Exemple : un fichier est une séquence d'octets, indépendamment de son

contenu

$FF $D8 $FF $E0 $00 $10 $4A $46 $49

$46 $00 $01 $01 $01 $01 $2C...

$50 $4B $03 $04 $14 $00 $06 $00 $08

$00 $00 $00 $21 $00 $4B $51...
• Besoin de conventions pour coder/décoder les informations

Architecture des ordinateurs 40

 Unicode - Implémentations
• UTF-8 : codage à longueur variable

: U+1D11E →décimal 119 070 → binaire 000 011101 000100 011110 (21 bits)
--> Code UTF-8 11110000 10011101 10000100 10011110
• UTF-16 : les code points plus utilisés sur 16 bits, les autres sur 32 bits (avec
des calculs…pas détaillés).
• UTF-32 : représentation d’un code point sur 32 bits.

Architecture des ordinateurs 41

CHAPITRE III
Le processeur

Architecture des ordinateurs

 Le processeur
• Processeur : cerveau de l’ordinateur. Rôle : Exécuter des programmes
(séquence d’instructions)
• Il se compose de deux parties.

Chemin de données

Mémoir
R0
e R R1

A RI CO
R2
. UAL
UAL Séquenceur
D .

M R7 (Control
Unit)

• Chemin de données : registres, UAL, bus.

• Séquenceur : régit le fonctionnement du chemin de données.
Architecture des ordinateurs 43
La mémoire

Mémoire

0 adresse
1
2
un mot 1011110001101011 3
(M[4]) 4
…
donnée ou
instruction

mots de taille
constante (ici 16 bits)
Architecture des ordinateurs 44
Instructions
• Instruction : opération élémentaire qu’un processeur peut effectuer.
– nombre binaire sur 16 bits.
• Jeu d’instructions : ensemble d’instructions qu’un processeur peut exécuter.
• Exemple : un processeur avec quatre instructions (plus tard on verra un
exemple beaucoup plus complexe!!).
– LOAD rx a : Rrx ← M[a].
– STORE rx a : M[a] ← Rrx.
– ADD rx ry rz : Rrx ← Rry + Rrz.
– SUB rx ry rz : Rrx ← Rry – Rrz.
• Soit I un nombre binaire sur 16 bits. Comment le processeur sait-il à quelle
instruction I correspond?

Codes opérations
• 00 : LOAD
Choix
2 bits 14 bits • 01 : STORE
• 10 : ADD arbitraire!!
• 11 : SUB
Code opération Opérandes
Architecture des ordinateurs 45
Instructions
• LOAD 0 5 : R0 ← M[5] Codes opérations
• 00 : LOAD
• 01 : STORE
• 10 : ADD
00 00000000000101 • 11 : SUB

• LOAD 1 6 : R1 ← M[6]

00 00100000000110

• ADD 2 0 1 : R2 ← R0 + R1

10 010000001XXXXX

• STORE 2 6 : M[6] ← R2

01 01000000000110

Architecture des ordinateurs 46

Programme
Langage machine Assembleur Codes opérations
• 00 : LOAD
• 01 : STORE
• 10 : ADD
00 00000000000101 LOAD 0 5 • 11 : SUB

00 00100000000110 LOAD 1 6

10 010000001XXXXX ADD 2 0 1

01 01000000000110 STORE 2 6

Architecture des ordinateurs 47

 Exécution d’un programme
• Les instructions d’un programme sont stockées à des
adresses contiguës (la réalité est plus complexe).
Mémoire
• Le processeur lit de la mémoire les instructions du
programme une par une. 0000000000000101
0000100000000110 0
10010000001XXXXX
1
• L’adresse de la prochaine instruction à lire est 0101000000000110 2
3
stockée dans le Compteur Ordinal (CO) – Program 4
Counter (PC) – un registre du processeur. donnée 1
donnée 2
5
6

Processeur

Architecture des ordinateurs 48

 Exécution d’un programme
1. Fetch : l’instruction contenue à l’adresse indiquée par
le CO est copiée dans le registre d’instruction (RI) – ou
Instruction Register (IR) – un registre du processeur. Mémoire
2. Decode : Le processeur « comprend » l’instruction à
exécuter. 0000000000000101
0000100000000110 0
3. Execute : L’instruction est exécutée par le processeur. 1
10010000001XXXXX
La valeur contenue dans le CO est incrémenté.
0101000000000110 2
3
donnée 1 4
2 DECODE donnée 2
5
6

1 FETCH

Processeur

3 EXECUTE
Architecture des ordinateurs 49
 Architecture de Von Neumann
• L’architecture que nous avons présentée a été décrite
en 1945 par John Von Neumann. Mémoire
• L’architecture de Von Neumann est à la base du
fonctionnement des ordinateurs modernes.
0000000000000101
• Trois principes à retenir:
0000100000000110 0
1. La mémoire est une matrice de mots, chaque mot a son 1
10010000001XXXXX
adresse.
0101000000000110 2
2. Un mot peut contenir soit une donnée soit une 3
instruction. 4
3. Les mots ont une taille constante. donnée 1
donnée 2
5
6

Processeur

Architecture des ordinateurs 50

MiniArm – Notre processeur du cours
• Nous allons définir MiniArm, un processeur simplifié.
– cependant suffisamment complexe pour comprendre les principes qui sont à la base
du fonctionnement d’un processeur réel.

• Registres : RI, CO, RADM, 8 registres banalisés (R0,…, R7), registre d’état (SR).
– tous les registres sont à 16 bits.

• UAL à 16 bits.

• Jeu de 9 instructions.
– petit mais suffisant pour coder des programmes complexes.
– instructions de branchement (jump).

• Introduction de la notion de mode d’adressage.

Architecture des ordinateurs 51

 Instructions de branchement
• Instruction de branchement : saute à une adresse spécifiée
pour poursuivre l’exécution du programme. Mémoire
• Utile quand on veut faire appel à une fonction dont on
connaît l’adresse de la première instruction. 0000000000000101
0000100000000110 0
10010000001XXXXX
1
0101000000000110
2
branchement 7
3
donnée 1 4
donnée 2
5
0000000000001000
6
7
8
9
10

Processeur

Architecture des ordinateurs 52

Mode d’adressage
• Une instruction peut avoir zéro ou plusieurs opérandes.
– opérandes sources : ceux qui ne sont pas changés après l’exécution de l’instruction.
– opérandes cibles : ceux qui sont changés après l’exécution de l’instruction.
– Exemple : dans LOAD 0 5, 0 est l’opérande cible, 5 est l’opérande source.
• Mode d’adressage : règle qui régit la manière dont une instruction identifie
ses opérandes.
– pour simplifier, nous considérons seulement les opérandes sources.
• Dans l’instruction LOAD 0 5 :
– L’opérande source (5) est immédiatement disponible dans l’instruction (il ne faut pas
le chercher dans un registre).
– Ceci est un exemple de mode d’adressage immédiat.
• Dans l’instruction ADD 2 0 1 :
– L’instruction contient les identifiants des deux registres (0 et 1) qui contiennent les
opérandes sources.
– Ces opérandes ne sont pas immédiatement disponibles dans l’instruction.
• il faut les chercher dans les deux registres.
– Ceci est un exemple de mode d’adressage direct.

Architecture des ordinateurs 53

Modes d’adressage de MiniArm
• Mode d’adressage immédiat : l’opérande est codé dans l’instruction.
– immédiatement disponible.
• Mode d’adressage direct : l’opérande est dans un registre (dont l’identifiant
est codé dans l’instruction).
– disponible à partir directement de l’instruction.
– il suffit de le chercher dans le registre indiqué dans l’instruction.
• Chaque instruction de MiniArm a une version en adressage immédiat et en
adressage direct pour les opérandes sources.
– les opérandes cibles sont toujours des identifiants de registres.
– quelques exceptions que nous allons voir.
• Normalement un processeur réel a plus de deux modes d’adressages.
– pour les opérandes sources et cibles.

Architecture des ordinateurs 54

Format des instructions de MiniArm
• Les instructions qui utilisent l’adressage direct sont codées sur 1 mot.
• Le dernier bit de OpCode à 0 indique que cette instruction utilise un
adressage direct.
• Possibilité de référencer jusqu’à 3 registres banalisés (3 bits pour chaque
registre).
iiii0 xxx yyy zzzii 16 bits
OpCode (5 bits) référence à des registres (11 bits)
• Les instructions qui utilisent l’adressage immédiat sont codées sur 2 mots.
• Le dernier bit de OpCode à 1 indique que cette instruction utilise un
adressage immédiat.
• Le deuxième mot contient la valeur de l’opérande immédiatement
disponible.
OpCode (5 bits) référence à des registres (11 bits)
iiii1 xxx yyy zzzii
16 bits
iiiiiiiiiiiiiiii
opérande immédiatement disponible (16 bits)
Architecture des ordinateurs 55
Le processeur MiniArm

OpCode rx ry rz
(5 bits) (3 bits) (3 bits) (3 bits)

opérande auxiliaire (16 bits)

Architecture des ordinateurs 56

Instructions de MiniArm
• LDR : copie la valeur d’un mot de mémoire dans un registre.

• STR : copie la valeur d’un registre dans un mot de mémoire.

• MOV : copie une valeur d’un registre dans un autre registre.

• ADD : copie la somme des valeurs de deux registres dans un registre.

• SUB : copie la soustraction des valeurs de deux registres dans un registre.

• CMP : compare les valeurs de deux registres et modifie les signaux du

registre d’état en conséquence.

• BEQ, BLT, B : instructions de branchement.

Architecture des ordinateurs 57

LDR
• LDR adressage direct : ldr rx, ry
• Effet : Rrx ← M[Rry]

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00000 rx ry

• LDR adressage immédiat : ldr rx, a

• Effet : Rrx ← M[a]

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00001 rx
a

Architecture des ordinateurs 58

STR
• STR adressage direct : str rz, ry
• Effet : M[Rry]← Rrz

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00010 ry rz

• STR adressage immédiat : str rz, a

• Effet : M[a] ← Rrz

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00011 rz
a

Architecture des ordinateurs 59

MOV
• MOV adressage direct : mov rx, ry
• Effet : Rrx← Rry

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00100 rx ry

• MOV adressage immédiat : mov rx, v

• Effet : Rrx ← v

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00101 rx
v

Architecture des ordinateurs 60

ADD
• ADD adressage direct : add rx, ry, rz
• Effet : Rrx← Rry + Rrz

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00110 rx ry rz

• ADD adressage immédiat : add rx, ry, v

• Effet : Rrx ← Rry + v

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

00111 rx ry
v

Architecture des ordinateurs 61

SUB
• SUB adressage direct : sub rx, ry, rz
• Effet : Rrx← Rry - Rrz

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01000 rx ry rz

• SUB adressage immédiat : sub rx, ry, v

• Effet : Rrx ← Rry - v

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01001 rx ry
v

Architecture des ordinateurs 62

CMP
• CMP adressage direct : cmp ry, rz
• Effet : N ← (Rry < Rrz); Z ← (Rry = Rrz)

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01010 ry rz

• CMP adressage immédiat : cmp ry, v

• Effet :N ← (Rry < v); Z ← (Rry = v)

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01011 ry
v

Architecture des ordinateurs 63

BEQ
• BEQ adressage direct : beq rz
• Effet : CO ← Rrz si Z=1

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01100 rz

• BEQ adressage immédiat : beq a

• Effet : CO ← a si Z=1

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01101
a

Architecture des ordinateurs 64

BLT
• BLT adressage direct : blt rz
• Effet : CO ← Rrz si N=1

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01110 rz

• BLT adressage immédiat : blt a

• Effet : CO ← a si N=1

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

01111
a

Architecture des ordinateurs 65

B
• B adressage direct : b rz
• Effet : CO ← Rrz

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

10000 rz

• B adressage immédiat : b a
• Effet : CO ← a

OpCode (5 bits) 3 bits 3 bits 3 bits 2 bits

10001
a

Architecture des ordinateurs 66

Exécution des instructions
• Pour exécuter des instructions, il faut piloter le chemin des données.
– il faut changer les valeurs des signaux (COA, MemB, CodeUAL, …) pour que les
données aillent « aux bons endroits ».
– exemple de ADD.

• Le chemin de données est piloté par le séquenceur.

Architecture des ordinateurs 67

Le séquenceur de MiniArm

Signal T : temps de configuration

Signal P : temps de mémorisation

Architecture des ordinateurs 68

Réalisation du séquenceur – Étapes
• Création d’un tableau des temps
– Une ligne pour chaque instruction
– Une colonne pour chaque temps d’horloge (T1, P1, T2, P2..)
– Pour chaque temps, les signaux du chemin de données à activer (= mettre à 1)

• Dérivation d’un ensemble d’équations logiques

– Une équation pour chaque signal du chemin de données
– Une équation communique quand un signal doit être activé
– Une équation est fonction des entrées du séquenceur et des signaux T, P

Architecture des ordinateurs 69

 Tableau des temps – Fetch

RADM ← CO

COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HRADM HRI HCO

T1 P1 T2 P2
COA = 1 HRADM
CodeUAL= A

Architecture des ordinateurs 70

 Tableau des temps – Fetch
RI ← Mem[RADM]
CO ← CO + 1
COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HRADM HRI HCO

T1 P1 T2 P2
COA = 1 HRADM COA = 1 HRI; HCO
CodeUAL= A CodeUAL = A + 1

Architecture des ordinateurs 71

 Tableau des temps – Execute (mov rx, v)
RADM ← CO

COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HRADM HCO

T3 P3 T4 P4 T5 P5
COA=1 HRADM
CodeUAL = A

Architecture des ordinateurs 72

 Tableau des temps – Execute (mov rx, v)
CO ← CO + 1

COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HCO

T3 P3 T4 P4 T5 P5
COA=1 HRADM COA = 1 HCO
CodeUAL = A CodeUAL = A + 1

Architecture des ordinateurs 73

 Tableau des temps – Execute (mov rx, v)
rx ← Mem[RADM] MemB

A B
R A R
A D RI CO R
D A r
M M
D x r CodeUAL
x
HR

T3 P3 T4 P4 T5 P5
COA=1 HRADM COA = 1 HCO MemB = 1 HR
CodeUAL = A CodeUAL = A + 1 CodeUAL = B

Architecture des ordinateurs 74

 Tableau des temps – Execute (mov rx, ry)
rx ← ry

not COA

r A B
R A R r y
A D RI CO R
D A yr
M M
D x r CodeUAL
x
HR

T3 P3 T4 P4 T5 P5
CUAL = A HR

Architecture des ordinateurs 75

 Tableau des temps – Execute (add rx, ry, rz)
rx ← ry + rz not MemB

not COA

r r r A B
R A R zr y z
A D RI CO R
D A yr
M M
D x r CodeUAL
x
HR

T3 P3 T4 P4 T5 P5
CodeUAL = A + B HR

Architecture des ordinateurs 76

 Tableau des temps – Execute (beq a)
RADM ← CO

COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HRADM HCO

T3 P3 T4 P4 T5 P5
COA=1 HRADM
CodeUAL = A

Architecture des ordinateurs 77

 Tableau des temps – Execute (beq a)
CO ← CO + 1

COA

A B
R A R
A D RI CO R
D A
M M
D CodeUAL

HCO

T3 P3 T4 P4 T5 P5
COA=1 HRADM COA = 1 HCO
CodeUAL = A CodeUAL = A + 1

Architecture des ordinateurs 78

 Tableau des temps – Execute (beq a)
CO ← Mem[RADM] MemB

A B
R A R
A D RI CO R
D A
M M
D CodeUAL Z

HCO

T3 P3 T4 P4 T5 P5
COA=1 HRADM COA = 1 HCO MemB = 1 HCO si Z
CodeUAL = A CodeUAL = A + 1 CodeUAL = B

Architecture des ordinateurs 79

 Équations logiques
Inst. T1 P1 T2 P2 T3 P3 T4 P4 T5 P5
COA=1
mov rx, COA=1 HRI COA=1 COA=1 MemB=1
CodeUAL=A HRADM HRADM HCO HR
#val CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 CodeUAL=B

COA=1
COA=1 HRI
mov rx, ry CodeUAL=A HRADM CodeUAL=A HR
CodeUAL=A+1 HCO

add rx, ry, COA=1 COA=1 HRI

HRADM CodeUAL=A + B HR
rz CodeUAL=A CodeUAL=A+1 HCO

MemB=1
beq COA=1 COA=1 HRI COA=1 COA=1 HCO
HRADM HRADM HCO CodeUAL=B
address CodeUAL=A CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 si Z

Architecture des ordinateurs 80

 Équations logiques
Inst. T1 P1 T2 P2 T3 P3 T4 P4 T5 P5
COA=1
mov rx, COA=1 HRI COA=1 COA=1 MemB=1
CodeUAL=A HRADM HRADM HCO HR
#val CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 CodeUAL=B

COA=1
COA=1 HRI
mov rx, ry CodeUAL=A HRADM CodeUAL=A HR
CodeUAL=A+1 HCO

add rx, ry, COA=1 COA=1 HRI

HRADM CodeUAL=A + B HR
rz CodeUAL=A CodeUAL=A+1 HCO

MemB=1
beq COA=1 COA=1 HRI COA=1 COA=1 HCO
HRADM HRADM HCO CodeUAL=B
address CodeUAL=A CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 si Z

• COA = T1

Architecture des ordinateurs 81

 Équations logiques
Inst. T1 P1 T2 P2 T3 P3 T4 P4 T5 P5
COA=1
mov rx, COA=1 HRI COA=1 COA=1 MemB=1
CodeUAL=A HRADM HRADM HCO HR
#val CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 CodeUAL=B

COA=1
COA=1 HRI
mov rx, ry CodeUAL=A HRADM CodeUAL=A HR
CodeUAL=A+1 HCO

add rx, ry, COA=1 COA=1 HRI

HRADM CodeUAL=A + B HR
rz CodeUAL=A CodeUAL=A+1 HCO

MemB=1
beq COA=1 COA=1 HRI COA=1 COA=1 HCO
HRADM HRADM HCO CodeUAL=B
address CodeUAL=A CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 si Z

• COA = T1 + T2

Architecture des ordinateurs 82

 Équations logiques
Inst. T1 P1 T2 P2 T3 P3 T4 P4 T5 P5
COA=1
mov rx, COA=1 HRI COA=1 COA=1 MemB=1
CodeUAL=A HRADM HRADM HCO HR
#val CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 CodeUAL=B

COA=1
COA=1 HRI
mov rx, ry CodeUAL=A HRADM CodeUAL=A HR
CodeUAL=A+1 HCO

add rx, ry, COA=1 COA=1 HRI

HRADM CodeUAL=A + B HR
rz CodeUAL=A CodeUAL=A+1 HCO

MemB=1
beq COA=1 COA=1 HRI COA=1 COA=1 HCO
HRADM HRADM HCO CodeUAL=B
address CodeUAL=A CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 si Z

• COA = T1 + T2 + T3 * IMM + T4*IMM

Architecture des ordinateurs 83

 Équations logiques
Inst. T1 P1 T2 P2 T3 P3 T4 P4 T5 P5
COA=1
mov rx, COA=1 HRI COA=1 COA=1 MemB=1
CodeUAL=A HRADM HRADM HCO HR
#val CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 CodeUAL=B

COA=1
COA=1 HRI
mov rx, ry CodeUAL=A HRADM CodeUAL=A HR
CodeUAL=A+1 HCO

add rx, ry, COA=1 COA=1 HRI

HRADM CodeUAL=A + B HR
rz CodeUAL=A CodeUAL=A+1 HCO

MemB=1
beq COA=1 COA=1 HRI COA=1 COA=1 HCO
HRADM HRADM HCO CodeUAL=B
address CodeUAL=A CodeUAL=A+1 HCO CodeUAL=A CodeUAL=A+1 si Z

• COA = T1 + T2 + T3 * IMM + T4*IMM

• HRADM = P1 + P3*IMM
• HR = P5 * !BEQ ou HR = P5 * (MOV + ADD)
• HCO = P2 + P4 * IMM + P5 * BEQ * Z

Architecture des ordinateurs 84

CHAPITRE IV
Langages de programmation

Architecture des ordinateurs

 Langage machine : quels problèmes?

2900 0000 2A00 0001 3128 3A40 0001 5840

000B 7800 0004 8800 000B

• Programme utilisant le langage machine du processeur MiniArm.

• Difficile à lire : chaque instruction est une suite de nombres binaires (bits).
• Qu’est-ce que ce programme fait?

Interagir directement avec la machine est difficile : fossé sémantique.

Architecture des ordinateurs 86

 Langage d’assemblage
@begin mov r1,#0x0000
mov r2,#0x0001
@loop add r1,r1,r2
add r2,r2,#0x0001
cmp r2,#0x000B
blt loop
@end b end

• Langage d’assemblage : représentation symbolique du langage machine

– Plus facile à apprendre, il ne faut pas manipuler du code binaire/hexadécimal.
• Assembleur : programme traduisant langage d’assemblage en langage machine
– L’assembleur est écrit en langage machine.
• Programmes en langage d’assemblage : complexes.
– Il s’agit encore de langage machine.
– Il faut bien connaître les détails techniques du processeur.

Architecture des ordinateurs 87

 Langage de haut niveau
total = 0;
for i in range(1, 11):
total += i
print total

• Langage de haut niveau : expression d’instructions en utilisant des mots et des

symboles mathématiques.
– Facile à apprendre.
– Il ne nécessite pas une connaissance du processeur de la machine.

• Langages de haut niveau : Java, C, C++, Pascal, Python …

Architecture des ordinateurs 88

 Pouvez-vous voir les bénéfices?
2900 @begin mov r1,#0x0000 total = 0;
0000 mov r2,#0x0001 for i in range(1, 11):
2A00 @loop add r1,r1,r2 total += i
0001 add r2,r2,#0x0001 print total
3128 cmp r2,#0x000B
3A40 blt loop
Haut niveau
0001 @end b end
5840
000B
7800
0004
8800
000B

Bas niveau

Architecture des ordinateurs 89

Fossé sémantique
• Le processeur « parle » binaire.

• Le programmateur « parle » Python.

• Il faut un intermédiaire pour faire communiquer le programmateur et le

processeur.

• Deux options :
– compilation.
– interprétation.

Architecture des ordinateurs 90

 Langages compilés

Code source
MonProg.c
Plus besoin du code source
Compilation Plus besoin du compilateur

Code exécutable Code exécutable Code exécutable

[Link] [Link] [Link]

Exécution 1 Exécution 2
La compilation est
effectuée une seule
fois
Matériel Matériel

Architecture des ordinateurs 91

 Langages compilés
int difference (int x, int y)
Source {
MonProg.c int r;
r = x-y;
return r;
}

mov edx, [ebp+0xc] 0110110011001100

Exécutable mov eax, [ebp+0x8] 0110011011001000
[Link] sub eax, edx 1100101111010110
mov [ebp-0x4], eax 1010011011001110
mov eax, [ebp-0x4] 0110011011011100

Architecture des ordinateurs 92

Qui compile le compilateur?
• Un compilateur est un programme
– préférable d’utiliser un langage de haut niveau pour l’écrire.
– par exemple, on peut écrire un compilateur C en Pascal.
– mais un compilateur Pascal doit déjà exister.

• Nous avons besoin d’un compilateur pour traduire du code C dans le code
machine d’un nouveau processeur.

• Premier choix : écrire le compilateur en langage machine (pas sympa!)

– Les premiers compilateur étaient écrits en langage machine (Fortran, 1954 - 1957)

• Deuxième choix : bootstrapping

– On crée un compilateur en C qui compile du code C !
• paradoxe?

Architecture des ordinateurs 93

Bootstrapping

Machine A But : compilateur C → ARM Machine B

Intel CPU ARM CPU

Compilateur C → ARM
écrit en C

Compilateur C → ARM
Compilateur C → Intel exécutable sur ARM

Compilateur C → ARM
(exécutable sur Intel)

Architecture des ordinateurs 94

 Langages interprétés

Code source Code source

[Link] [Link]
Interprétation 1 Interprétation 2 Toujours besoin du code
source
interprète interprète Toujours besoin de
[Link] [Link] l’interprète

Exécution 1 Exécution 2

Matériel Matériel

Architecture des ordinateurs 95

 Langages interprétés

Code source de
function factorial (n){
l’interprète javascript.c x=1;
for (i=2;i<=n;i++) x=x*i;
char word[100]; return x; }
char prog[100000];
// charger fichier prog
Interprétation
...
// boucle d'exécution
do{ 011010001010011
011010001010011
readNextWord(word,pro 011010001010011
[Link]
g); 011010001010011
if (!strcmp(word,"if")) 011010001010011
... tester ce qui vient compilation 011010001010011
if (!strcmp(word,"for")) 011010001010011
... répéter ce qui vient
if (!strcmp(word,"=")) Exécution
... affecter
if (!strcmp(word,"=="))
... calcul booléen égalité
... Matériel
} while (progPasFini);

Architecture des ordinateurs 96

Langages interprétés
• Avantages
– souplesse, on peut modifier le code sans avoir à régénérer un fichier exécutable.
– sécurité, l’interprète vérifie si un programme fait des opérations dangereuses.
– portabilité, on peut exécuter du code sur un ordinateur quelconque où l’interpréteur
est installé.
– accessibilité du code source.
• Inconvénients
– plus lent : il faut retraduire les instructions à chaque fois
– le code source est toujours accessible
• Approches hybrides : langages compilés/interprétés (par ex., Java, Python)
– Code source : [Link]
– Un compilateur convertit le fichier source [Link] en fichier [Link]
– [Link] est écrit en bytecode.
– Bytecode : jeu d’instructions indépendant d’un processeur réel, il n’est pas
directement exécutable par le processeur
– Le Bytecode est exécuté par la Java Virtual Machine.

Architecture des ordinateurs 97

Langages de haut niveau : concepts
• Les langages de programmation de haut niveau proposent des concepts
abstraits qui ne sont pas présents dans le langage machine.
• Types de données : entiers, réels, string….
• Structures de contrôle : if....then....else, while, for, fonctions.

• Représentation des données au niveau du processeur :

– Mots de 8, 16, 32 ou 64 bits.
– Un mot permet d’identifier une instruction, une adresse et/ou une donnée.

• Représentation des données dans un langage de programmation haut niveau

:
– booléens : faux, vrai
– entiers : complément à deux
– flottants : norme IEEE 754
– caractères : Unicode, UTF-8
– tableaux et structures : mots consécutifs en mémoire.

Architecture des ordinateurs 98

Structures de contrôle
• Le langages de programmation fournissent un ensemble de structures de
contrôle.
– conditions : if…then...else; switch...case
– boucles : while; for
– appels de fonction.

• Ces structures utilisent des opérateurs de comparaison :

– <=, >=, ==, >, <

• Comment ces structures de contrôle sont-elles traduites par le compilateur

en langage machine?

• Notre processeur MiniArm dispose d’un ensemble limité d’instructions:

– cmp, b, beq, blt

Architecture des ordinateurs 99

Conditions
cmp r0, r1
if r0 == r1 : beq vrai
r0 = r1 – r0 sub r1, r0, r1
else : b fin
r1 = r0 – r1 @vrai sub r0, r1, r0
@fin b fin

cmp r0, r1
if r0 != r1 : beq faux
r0 = r1 – r0 sub r0, r1, r0
else : b fin
r1 = r0 – r1 @faux sub r1, r0, r1
@fin b fin

Architecture des ordinateurs 100

Conditions

cmp r0, r1
if r0 < r1 : blt vrai
r0 = r1 – r0 sub r1, r0, r1
else : b fin
r1 = r0 – r1 @vrai sub r0, r1, r0
@fin b fin

Architecture des ordinateurs 101

 Conditions
if r0 <= r1 : if r1 < r0 :
r0 = r1 – r0 r1 = r0 – r1
else : else :
r1 = r0 – r1 r0 = r1 – r0

cmp r1, r0
blt vrai
sub r0, r1, r0
b fin
@vrai sub r1, r0, r1
@fin b fin

Architecture des ordinateurs 102

Conditions

if r0 > r1 : if r1 < r0 :
r0 = r1 – r0 r0 = r1 – r0
else : else :
r1 = r0 – r1 r1 = r0 – r1

cmp r1, r0
blt vrai
sub r1, r0, r1
b fin
@vrai sub r0, r1, r0
@fin b fin

Architecture des ordinateurs 103

 Conditions

if r0 >= r1 : if r0 < r1 :
r0 = r1 – r0 r1 = r0 – r1
else : else :
r1 = r0 – r1 r0 = r1 – r0

cmp r0, r1
blt vrai
sub r0, r1, r0
b fin
@vrai sub r1, r0, r1
@fin b fin

Architecture des ordinateurs 104

 Boucles

mov r2, #0
r2 = 0 @loop cmp r0, r1
while r0 >= r1 : blt fin
r0 = r1 – r0 sub r0, r1, r0
r2 = r2 + 1 add r2, r2, #1
b loop
@fin

Architecture des ordinateurs 105

 Appel de fonctions
• La possibilité de définir et appeler des fonctions est fondamentale dans tout
langage moderne.
• Une fonction est définie une fois seulement.
• Une fonction peut être appelée plusieurs fois
– Réutilisation du code Une fonction est
identifiée par l’adresse
de sa première
main instruction

arguments: a, b mult(a, b)
mult (a, b)

résultat: a * b

Architecture des ordinateurs 106

 Appel de fonction

• Le programme appelant une fonction doit reprendre son exécution une fois
l’exécution de la fonction terminée.
• Besoin de sauvegarder l’adresse de l’instruction qui suit l’appel de fonction.
– Cette adresse est contenue dans le compteur ordinal.
– On appelle cette adresse : adresse de retour.
• Besoin de passer des arguments à la fonction. Où peut-on les sauvegarder?
main
trier(T) max(a, b)
trier(T)
max(a, b)

trier(a, b)

Architecture des ordinateurs 107

 Appel de fonction

Mémoire

• Un appel de fonction s’effectue avec une instruction 0

de branchement. 1
….......
2
• Comment la fonction main passe-t-elle ses arguments
….......
3
à la fonction mult?
….........
4
main
…........
5
b 13 6
• Comment la fonction mult passe-t-elle son résultat à
la fonction main?
….........
7
….......
8
…........
9
• Comment la fonction mult sait-elle que l’adresse de ….........
10
retour est 7? 11
12
…..........

….........
13
mult …...........

….........

b7

Architecture des ordinateurs 108

 Appel de fonction
• La fonction main sauvegarde les deux arguments (3 et 4) dans les registres r0 et r1
respectivement.
• La fonction main sauvegarde l’adresse de retour dans le registre r7.
• La fonction mult trouve ses arguments dans les registres r0 et r1.
• La fonction mult place le résultat dans r2.
• A la fin, la fonction mult saute à l’adresse de retour contenue dans le registre r7.
r0 r1 r2 r3 r4 r5 r6 r7
3 4 ret

@main mov r0, #3 @mult mov r2, #0 Problèmes.

mov r1, #4 @loop cmp r0, #0 • mult écrase la valeur du registre r2.
mov r7, next beq fin Et si ce registre était utilisé par le
b mult add r2, r2, r1 programme main?
@ret ….. sub r0, r0, #1 • Si mult appelle une autre fonction,
b loop elle écrase la valeur du registre r7.
@fin mov r0, r2 • Même problème dans le cas de
b r7 fonctions récursives.
Architecture des ordinateurs 109
 Le concept de pile
• La pile (stack) est une zone de mémoire de taille variable.

• La base de la pile est la première adresse utilisable de la pile.

Mémoire

• La limite de la pile est la dernière adresse utilisable de la pile.

• Essayer d’ajouter des éléments en dessous de la limite ou en

dessus de la base provoque un débordement de la pile
(stack overflow).

Base de la
pile

pile

Limite de la
pile

Architecture des ordinateurs 110

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

pile

Architecture des ordinateurs 111

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1

SP d1

pile

Architecture des ordinateurs 112

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1
push d2

SP d1
d2

pile

Architecture des ordinateurs 113

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1
push d2
push d3

SP d1
d2
d3

pile

Architecture des ordinateurs 114

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1
push d2
push d3

SP d1
d2
d3

• L’opération pour éliminer la dernière donnée ajoutée à la pile et pile

la copier dans un registre du processeur s’appelle pop.

Architecture des ordinateurs 115

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1
push d2
push d3

SP d1
d2
d3

• L’opération pour éliminer la dernière donnée ajoutée à la pile et pile

la copier dans un registre du processeur s’appelle pop.

pop r1 r1 d3

Architecture des ordinateurs 116

 Le concept de pile
• L’opération permettant d’ajouter une donnée à la pile est
nommée push.
Mémoire
• L’adresse de la dernière donnée ajoutée à la pile est gardée dans
un registre du processeur qui s’appelle stack pointer (SP).

push d1
push d2
push d3

SP d1
d2
d3

• L’opération pour éliminer la dernière donnée ajoutée à la pile et pile

la copier dans un registre du processeur s’appelle pop.

pop r1 r1 d3

pop r2 r2 d2

Architecture des ordinateurs 117

Appel de fonction avec une pile

@main mov sp, stack @mult push r2

mov r0, #3 mov r2, #0
mov r1, #4 @loop cmp r0, #0
mov r7, #next beq fin
b mult add r2, r2, r1
@next ….. sub r0, r0, #1
b loop
@stack rmw 1 @fin mov r0, r2
pop r2
b r7

Architecture des ordinateurs 118

Fonction récursive
• La fonction main met l’argument (2) dans le registre r0.
• La fonction rec met l’argument (x-1) dans le registre r0.
• Les deux fonctions mettent l’adresse de retour dans le registre r7.
• La fonction rec met le résultat dans le registre r2.

main:
rec(2)

rec(x) :
if x == 0:
return 1;
else:
return rec(x-1) + x

Architecture des ordinateurs 119

Fonction récursive
Code machine de la fonction main.

@maink mov sp, stack

main: @maink mov r0, #2
rec(2) @maink push r2
@maink mov r7, rtn
rec(x) : @maink b rec
if x == 0: @rtn mov r0, r2
@maink pop r2
return 1;
@finnk b fin
else:
return rec(x-1) + x @stack rmw 1

Architecture des ordinateurs 120

Fonction récursive
Code machine de la fonction rec.

@rect push r1
@rect mov r1, #1
main: @rect cmp r0, #0
rec(2) @rect beq end
@rect push r0
rec(x) : @rect sub r0, r0, #1
if x == 0: @rect push r7
@rect mov r7, next
return 1;
@rect b rec
else: @next pop r7
return rec(x-1) + x @fin pop r0
@next add r1, r2, r0
@end mov r2, r1
@fin pop r1
@fin b r7

Architecture des ordinateurs 121

 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @main @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 zzzz @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0
@rect sub r0, r0, #1 SP
@rect push r7
?????
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 yyyy
@fin pop r1
@fin b r7
Architecture des ordinateurs 122
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @main+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 zzzz @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0
@rect sub r0, r0, #1 SP
@rect push r7
@stack
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 yyyy
@fin pop r1
@fin b r7
Architecture des ordinateurs 123
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @main+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0
@rect sub r0, r0, #1 SP
@rect push r7
@stack
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 yyyy
@fin pop r1
@fin b r7
Architecture des ordinateurs 124
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @main+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
@rect push r7
@stack+1
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 yyyy
@fin pop r1
@fin b r7
Architecture des ordinateurs 125
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @main+4 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
@rect push r7
@stack+1
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 126
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
@rect push r7
@stack+1
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 127
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7
@stack+2
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 128
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7
@stack+2
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 129
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7
@stack+2
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 130
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+4 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7
@stack+2
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 131
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+5 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+3
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 132
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+6 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+3
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 133
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+7 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+4 @rtn
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 134
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+8 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+4 @rtn
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 135
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+4 @rtn
@rect mov r7, next
pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 136
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 137
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 138
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 139
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+4 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 140
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+5 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+6 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 141
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+6 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+6 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 142
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+7 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+7 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 143
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+8 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+7 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 144
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+7 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 145
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+8 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 146
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+8 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 147
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rec+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+8 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 148
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @end @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+8 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 149
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @end+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+8 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 150
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @end+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+7 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 151
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+7 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 152
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 0 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+6 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 153
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 154
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 2 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
1 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 155
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+4 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 2 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+5 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 156
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+5 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+4 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 157
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+4 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @next
@fin pop r1
@fin b r7
Architecture des ordinateurs 158
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 1 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+3 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 159
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 1 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+2 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 160
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+3 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 4 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+2 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
2 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 161
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+4 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end 4 @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+2 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
4 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 162
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @next+5 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+1 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
4 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 163
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rtn @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 2 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+1 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
4 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 164
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rtn+1 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 4 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack+1 @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
4 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 165
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @rtn+2 @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 4 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 166
 Fonction récursive
@maink mov sp, stack
@maink mov r0, #2
CO
@maink push r2
@maink mov r7, rtn @fin @main
@maink b rec .
r0 .
@rtn mov r0, r2 @rect push r1 4 @rec
@maink pop r2 @rect mov r1, #1 .
@finnk b fin @rect cmp r0, #0 r1 .
@rect beq end rrrr @stack
@stack rmw 1 @rect push r0 xxxx
@rect sub r0, r0, #1 SP
rrrr
@rect push r7 2
@stack @rtn
@rect mov r7, next 1 pile
@rect b rec r2 1
pile @next pop r7 @next
xxxx 1
@fin pop r0
@next add r1, r2, r0 r7
@end mov r2, r1 @rtn
@fin pop r1
@fin b r7
Architecture des ordinateurs 167
CHAPITRE V
Mémoire

Architecture des ordinateurs

Hiérarchie mémoire

• rapidité décroissante
• taille croissante Processeur
• coût décroissant

Registres

Mémoire centrale

Mémoire secondaire

Architecture des ordinateurs 169

La mémoire centrale
• La technologie utilisée pour réaliser la mémoire centrale est DRAM.
• DRAM = Dynamic Random Access Memory
– Mémoire à accès direct (ou, aléatoire) dynamique.
• Mémoire à accès direct (RAM) : on accède directement à n'importe quel mot
de mémoire par son adresse.
– pour accéder au mot de mémoire à l’adresse x, il ne faut pas lire les mots de
mémoire aux adresses 0,…., x-1.
• Mémoire dynamique : le contenu de la mémoire doit être lu et réécrit
périodiquement (sinon il est perdu).
– lire et réécrire la mémoire : rafraîchissement de la mémoire.
• La mémoire centrale est volatile.
– en absence d’alimentation, tout son contenu est perdu!

Architecture des ordinateurs 170

 DRAM – Cellule de mémoire (Ière génération)
ligne de mot (adresse de ligne)
Mémoire : matrice de cellules
transistor

condensateur

ligne de bit
(colonne)

• Mémoire : matrice de cellules (la matrice n’est pas nécessairement carrée).

• Chaque cellule de mémoire contient 1 bit.
• Le bit est mémorisé sous forme de charge électrique dans le condensateur.
– condensateur chargé : bit 1, condensateur déchargé : bit 0.
• La charge dans un condensateur peut être gardée pendant plusieurs ms.
– rafraîchissement de la mémoire : recharger les condensateurs périodiquement
Architecture des ordinateurs 171
 DRAM – Puce de mémoire (Ière génération)
• La taille d’un mot de mémoire est 1 bit.
Exemple.
• Mémoire 256 x 1 : 256 cellules (cells) contenant 1 bit.
• Les cellules sont organisées dans une matrice 16x16.
Din Vcc • Pour accéder au contenu d’une cellule (1 bit), nous
avons besoin de deux adresses.
WE CAS – adresse de la ligne de la matrice (4 bits).
– adresse de la colonne de la matrice (4 bits).
RAS Dout
Mémoire • Les broches A0, A1, A2, A3 sont utilisées pour spécifier
A0 256 x 1 A2
une adresse.
– si RAS = 0 (Row Access Strobe), l’adresse sur ces broches est
interprété comme adresse de ligne
A1 A3
– si CAS = 0 (Column Address Strobe), l’adresse sur ces broches
est interprété comme adresse de colonne.
Vdd
• WE = 0 (Write Enable) : opération d’écriture.
– WE = 1 : opération de lecture.
(mémoire déjà avancée car les
• Din : donnée en entrée (1 bit)
adresses sont multiplexées.)
• Dout : donnée en sortie (1 bit)

Architecture des ordinateurs 172

1 DRAM – Puce de mémoire (Ière génération)
4 bits
Buffer adresse colonne Lecture d’une cellule
A0
A1
A2 CAS Décodeur adresse colonne
A3 6 1. On spécifie l’adresse de ligne.
2. On active le signal RAS.
3. Le décodeur sélectionne la ligne.
Décodeur adresse ligne

5
4. La ligne est envoyée au buffer de ligne.
Buffer adresse ligne

7
3 5. On spécifie l’adresse de colonne.
6. On active le signal CAS.
7. Le décodeur sélectionne la colonne.
8. Le bit à la colonne sélectionné dans le
buffer est envoyé sur la sortie.
RAS

Amplificateur / Ecriture
2
Din Buffer
Dout
4 8

Architecture des ordinateurs 173

 DRAM – Puce de mémoire (Ière génération)
Puce de mémoire Intel D2118-7.
[Link]

Attribut Valeur
Status Discontinued
Sub Category DRAMs
Access mode ---
Access Time-max 150ns
Memory width 1
Number of words code 16K
Operating mode ---
Organization 16Kx1

Taille de la mémoire : 16K bits = 24 * 210 bits = 21 * 210

bytes = 2 KB

Architecture des ordinateurs 174

 DRAM – Lecture (Ière génération)
• Sortie d’une opération de lecture : un mot.

Architecture des ordinateurs 175

 DRAM – Puce de mémoire (IIème génération)
4 bits
Buffer adresse colonne
• La mémoire consiste en une banque de
A0
plusieurs matrices de cellules.
A1
A2 CAS Décodeur adresse colonne
A3 Exemple
• Mémoire 256 x 2
• Une banque de deux matrices de
Décodeur adresse ligne

mémoire, chacune contenant 256 bits.

Buffer adresse ligne

• Chaque adresse (i, j) correspond à deux

bits
16x16 – 1 bit sur la première matrice.
– 1 bit sur la deuxième matrice.
• Mot de mémoire : 2 bits.

RAS
Amplificateur / Ecriture

Din Buffer
Dout

Architecture des ordinateurs 176

DRAM – Puce de mémoire (IIème génération)
Puce de mémoire Samsung K4E660412D-JC50.
[Link]

Architecture des ordinateurs 177

DRAM – Puce de mémoire (IIème génération)
Puce de mémoire Samsung K4E660412D-JC50.
[Link]

Attribut Valeur
Status Discontinued
Sub Category DRAMs
Access mode FAST PAGE WITH EDO
Access Time-max 50ns
Memory width 4
Number of words code 16M
Operating mode ASYNCHRONOUS
Organization 16Mx4

Taille de la mémoire : 16M * 4 bits = 24 * 220 * 22 bits

= 26 * 220 bits = 23 * 220 bytes = 8 MB

Architecture des ordinateurs 178

DRAM – IIème génération – Fast Page Mode
(FPM)
• On donne un signal RAS et 4 signaux CAS.
– On spécifie une adresse de ligne et on lit 4 colonnes sur cette ligne.
• Sortie d’une opération de lecture : 4 mots
• Il faut attendre le complètement d’une opération de lecture pour entamer la prochaine.

Architecture des ordinateurs 179

DRAM – IIème génération – EDO DRAM
• EDO : Extended Data Out.
• La sortie de la lecture en cours est enregistrée dans une mémoire tampon.
• On peut commencer la lecture suivante même avant la terminaison de la lecture
précédente.

Architecture des ordinateurs 180

 SDRAM – Puce de mémoire (IIIème génération)
4 bits
Buffer adresse colonne
• SDRAM : Synchronous DRAM
A0
A1 • La mémoire est synchrone
A2 CAS Décodeur adresse colonne – Le changement des signaux est réglé par
une horloge.
A3
• La mémoire consiste de plusieurs
banques de plusieurs matrices de
cellules.
Décodeur adresse ligne

• Seulement une banque est active à un

Buffer adresse ligne

moment donné.
• Avantage d’avoir deux banques :
16x16x2 lorsqu’on attend des données d’une
banque, on peut commencer la lecture
d’une autre banque.

RAS Exemple
• Mémoire 256 x 2 x 2.
Amplificateur / Ecriture
Logique de
• Deux banques de 256 mots de 2 bits.
sélection d’une
Din Dout • Mot de mémoire : 2 bits.
banque Buffer

Architecture des ordinateurs 181

SDRAM – Puce de mémoire (IIIème géneration)
Puce de mémoire Nanya NT5DS32M8BT-5T.
[Link]

Architecture des ordinateurs 182

SDRAM – Puce de mémoire (IIIème géneration)
Puce de mémoire Nanya NT5DS32M8BT-5T.
[Link]
496913/
Attribut Valeur
Status Discontinued
Sub Category DRAMs
Access mode FOUR BANK PAGE BURST
Access Time-max 0.6500 ns
Memory width 8
Number of words code 32M
Operating mode SYNCHRONOUS
Organization 32Mx8
Clock Frequency-Max (fCLK) 200 MHz

Taille de la mémoire : 32M * 8 bits = 25 * 220 * 23 bits

= 28 * 220 bits = 25 * 220 bytes = 32 MB
Architecture des ordinateurs 183
SDRAM – IIIème génération
• Une puce de mémoire SDRAM peut être programmée pour accéder à un nombre
variables de colonnes (burst mode)

Architecture des ordinateurs 184

 SDRAM – IIIème génération
Double data rate SDRAM : les données sont transférées sur le front montant et
sur le front descendant de l’horloge.

Fréquence interne
DDR Standard Horloge du bus (MHz) Débit de données (MT/s)
(MHz)
DDR 100 – 200 100 – 200 200 – 400
DDR2 200 – 533,33 100 – 266,67 400 – 1066,67
DDR3 400 – 1066,67 100 – 266,67 800 – 2133,33
DDR4 1066,67 – 2133,33 133,33 – 266,67 2133,33 – 4266,67

source : [Link]

Architecture des ordinateurs 185

La téchnologie DRAM – Module « 1-rank »

32M 32M 32M 32M 32M 32M 32M 32M

x8 x8 x8 x8 x8 x8 x8 x8

8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits

Mot de mémoire : 64 bits

• Le module contient 8 puces de 32MB.
• La taille du module est 256MB.

Architecture des ordinateurs 186

La technologie DRAM – Module « 2-rank »

16M 16M 16M 16M 16M 16M 16M 16M

x8 x8 x8 x8 x8 x8 x8 x8

8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits

Deux mots de mémoire de 64 bits
8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits 8 bits

16M 16M 16M 16M 16M 16M 16M 16M

x8 x8 x8 x8 x8 x8 x8 x8

Architecture des ordinateurs 187

La mémoire secondaire
• Mémoire non-volatile.
• Mémoire plus lente que la mémoire principale.
• Mémoire beaucoup plus grande que la mémoire principale.
• Il était une fois …. le ruban magnétique (introduit par IBM en 1953).
– Mémoire à accès séquentiel : pour lire une donnée, il faut parcourir toutes les
données précédentes.
• Aujourd’hui : disques magnétiques, SSD.

Architecture des ordinateurs 188

Disques magnétiques
• Il était une fois… RAMAC (Random-Access Method of Accounting Control)
– premier disque magnétique (1955).
– poids : une tonne (!)
– cinquante disques d’aluminium.

Architecture des ordinateurs 189

 Disques magnétiques
• Un disque est composé de plusieurs plateaux (platters).
– Chaque plateau consiste en deux surfaces.
– Vélocité de rotation : 5400, 7200, 10000, 15000 rpm.
• Il y a une tête (head) de lecture/écriture pour chaque plateau.
– les têtes ne peuvent pas se déplacer indépendamment.
• Le bras du disque (spindle) permet la rotation des plateaux .
• Chaque surface contient une collection de cercles concentriques, appelés pistes
(tracks).
• Une piste est divisée en un certain nombre de secteurs (sectors).
– taille fixe (typiquement 512 octets).

Piste Secteur

Architecture des ordinateurs 190

Solid-State Drive (SSD)
• Un dispositif SSD contient un certain nombre de mémoires flash NAND.
• Chaque mémoire flash NAND contient des cellules NAND organisées en
sous-ensembles.
– dans une cellule NAND : 1 bit (Single Level Cell) ou plusieurs (Multi Level Cell).
• La mémorisation d’un bit est obtenue par des transistors qui forment des
portes logiques NAND.
– par défaut : une cellule contient un bit 1.
– Opération de programmation (program) : mettre à zéro une cellule.
– Opération d’effacement (erase) : remettre le bit à 1.
– Chaque cycle program/erase (écriture) cause une usure de la cellule.

Architecture des ordinateurs 191

Avantages et inconvénients d’un SSD
Avantages :
• Rapide (pas de temps de positionnement)
• Résistant aux chocs.
• Pas de pièces mobiles.
– silencieux
– faible consommation d’énergie

Inconvénients :
• Plus cher qu’un disque magnétique.
• Capacité inférieure à un disque magnétique.
• Cycles d’écriture limités
– 1 à 2M cycles d’écriture pour SSD MLC
– ~5M cycles d’écriture pour SSD SLC

Architecture des ordinateurs 192

Caractéristiques
Temps Capacité Coût de
d’accès 1 Go
SRAM 10 ns 0,008 Go 5 000 €

DRAM (DDR4) 45 ns 32 Go 2,50 - 18 €

Flash (SSD) 34 400 ns 1 To 0,26 – 0,44 €

Disque 12 000 000 ns 8 To 0,030 €
dur

• Mémoire DRAM : module 32GB CT32G4RFD4213 (DDR4-2133R)

• Flash SSD : Samsung 850 Evo 1TB
• Disque dur : Seagate Archive HDD 8To S-ATA III

Architecture des ordinateurs 193

Accélération : mémoire cache
• Le processeur accède souvent aux mêmes mots de mémoire principale.
• Idée : ajouter une mémoire plus rapide entre le processeur et la mémoire
principale pour stocker les mots utilisés fréquemment.
– cette mémoire est appelée mémoire cache.
• La mémoire cache est une mémoire SRAM.
– La mémoire cache est donc plus rapide que la mémoire centrale (DRAM) ….
– …mais plus petite (car sinon elle coûterait une fortune!).
• Proximité temporelle
– Quand un processeur va chercher un mot en mémoire, il y a de fortes chances qu’il
aura besoin du même mot peu après
→ Garder les mots utilisés récemment dans la mémoire cache
• Proximité spatiale
– Quand un processeur va chercher un mot en mémoire, il y a de fortes chances qu’il ait
besoin d’un mot voisin peu après
→ Ne pas stocker un mot isolé dans la mémoire cache, mais un bloc de mots contigus en
mémoire

Architecture des ordinateurs 194

Principe du cache

adresse adresse
mot bloc Mémoire
Cache
centrale
contenu contenu
mot bloc
si miss

Architecture des ordinateurs 195

Organisation d’un cache
• La mémoire est vue “artificiellement” découpée en blocs de taille fixe.
• Un cache est organisé sous forme de N lignes, chaque ligne pouvant contenir
un bloc (pas toujours le même)

• Chaque ligne possède un descripteur permettant de savoir quel est le bloc

actuel qu’elle contient

Lignes
Bloc
D'
Susceptible d'aller dans
plusieurs lignes du cache

Mémoire Cache

Architecture des ordinateurs 196

Organisation : directement adressé
Un bloc donné ne peut aller que dans une seule ligne

0
1
2 3
3
32 4
5
6
7 5
57 8
9

Architecture des ordinateurs 197

Organisation : purement associatif
Un bloc donné peut aller partout dans le cache

3572
57
32

Architecture des ordinateurs 198

Organisation : associatif par sous-ensembles
Un bloc donné peut aller dans un sous-ensemble du cache

1
32 6
2
11
3

57 4

(two-way associative)
Architecture des ordinateurs 199
 Recherche d’un mot de mémoire dans le cache
Processeur
Adresse du mot en mémoire centrale

n bits
Mémoire cache

lignes
candidates

n. du bloc
• Le processeur demande un mot
par son adresse
• Le processeur ne demande pas descripteur
un bloc!
• Chaque bloc contient 4 mots
déplacement

Architecture des ordinateurs 200

 Décomposition d’une adresse mémoire
• Mémoire centrale : 32 (25) mots.
• Une adresse de mémoire est codée sur 5 bits.
• Taille d’un bloc : 4 (22) mots.
• Nombre de blocs dans la mémoire centrale : 8 (23).
00000
• Les trois bits de poids fort d’un mot indiquent le
00001 numéro de bloc d’appartenance d’un mot.
Bloc 0
00010 • Les deux derniers bits indiquent le déplacement
00011 dans le bloc pour atteindre le mot.
00100
00101
Bloc 1
ADRESSES

00110
00111
n. bloc depl.
…..... …..... …..... 3 bits 2 bits
11100
11101
Bloc 7
11110
11111

Architecture des ordinateurs 201

 Décomposition – Cache directement adressé
• Mémoire centrale : 32 (25) mots.
• Une adresse de mémoire est codée sur 5 bits.
• Taille d’un bloc : 4 (22) mots.
• Nombre de blocs dans la mémoire centrale : 8 (23).
00000
• Cache directement adressé avec 4 lignes.
00001
Bloc 0 • On peut caser 4 blocs au maximum.
00010
00011
Bloc 000 (0) et bloc 100 (4) Ligne 0
00100
Bloc 001 (1) et bloc 101 (5) Ligne 1
00101
Bloc 1
ADRESSES

00110 Bloc 010 (2) et bloc 110 (6) Ligne 2

00111
Bloc 011 (3) et bloc 111 (7) Ligne 3

…..... …..... ….....

11100
desc n. ligne depl.
11101
Bloc 7 1 bits 2 bits 2 bits
11110
11111 n. bloc
Architecture des ordinateurs 202
Exemple
• Mémoire centrale 4G (232)
• Une adresse de mémoire est codée sur 32 bits.
• Taille d’un bloc : 16 (24) mots.
• Nombre de blocs dans la mémoire centrale : 232/24 = 228
• Donc l’adresse sera composée de deux parties :
– le numéro de bloc (sur 28 bits)
– le déplacement dans un bloc (sur 4 bits)

32
28 4
1 adresse
n° bloc déplacement

Architecture des ordinateurs 203

 Recherche d’un mot – Cache directement
adressé

n° bloc
déplacement
déscripteur n° ligne
16 12 4

=? OK ?
• Cache directement adressé. ... ...
• Nombre de lignes : 4096 (212).

contenu descripteur
Architecture des ordinateurs cache s 204
Recherche d’un mot – Cache purement associatif

28 4
n° bloc
déplacement
déscripteur

=
=?
=?
O=?
K=?
?

... ...
=
=?
?
contenu descripteur
Architecture des ordinateurs cache s 205
Recherche d’un mot – Cache associatif par SE

n° bloc
déplacement
déscripteur n° sous-ensemble
18 10 4
=
=?
SE 0 O=?
K=?
?

... ...
SE 1023

contenu descripteur
Architecture des ordinateurs cache s 206
 Algorithmes de remplacement
• Quand la mémoire cache est pleine il faut choisir le bloc à éliminer pour faire
place à un nouveau bloc (sauf cache directement adressé).
• Algorithmes possibles :
– Random : on élimine un bloc au hasard.
– FIFO : on élimine le premier bloc qui a été ajouté à la mémoire cache.
– LRU (Least Recently Used) : on élimine le bloc qui a été utilisé le moins récemment.
• Nécessité d’ajouter des bits supplémentaires (age bits).
• Age bits : compteur. A chaque fois qu’on utilise un bloc le compteur est remis à 0.

1 ligne dans la
mémoire cache contenu (bloc) descripteur rempl. V

valid bit : si la ligne contient des données valides

(1 si la ligne n’est pas vide)

Architecture des ordinateurs 207

 Stratégies d'écriture
• Lorsqu’on change le contenu d’un bloc dans la mémoire cache, il faut aussi
changer le bloc correspondant en mémoire principale.
• Deux stratégies possibles : écriture immédiate ou écriture différée.
• Écriture immédiate (write-through).
– Le bloc modifié est écrit immédiatement en mémoire principale.
– Inconvénient : performance (un changement → deux écritures).
– Avantage : cohérence entre cache et mémoire centrale
• Écriture différée (write-back).
– Le bloc modifié est écrit en mémoire principale seulement lorsqu’il faut l’éliminer de
la mémoire cache.
– 1 bit W (dirty bit) pour chaque ligne.
– Avantage : performance.
– Inconvénient : le contenu du cache et celui de la mémoire centrale ne sont pas
cohérents.

1 ligne : contenu (bloc) descripteur rempl. V W

Architecture des ordinateurs 208

 Hiérarchie mémoire

• rapidité décroissante
• taille croissante
• coût décroissant
Registres

Mémoire cache

Mémoire centrale

Mémoire externe

Architecture des ordinateurs 209

CHAPITRE VI
Entrées/Sorties

Architecture des ordinateurs

Entrées/Sorties
• Entrées/sorties – E/S (input/output – IO) : échanges entre processeur et le
monde externe (utilisateur).

• Périphériques : dispositifs d’interface entre le processeur et l’utilisateur.

– clavier, souris, écran, imprimante, disque dur ….

• Les échanges s’effectuent grâce à un bus.

• Bus (latin : omnibus) : dispositif permettant la transmission de données

entre plusieurs composants.
– fils, fibre optique....

• Un bus permet de relier des composants indépendants.

– quand on change de clavier il ne faut pas changer de processeur...

Architecture des ordinateurs 211

 Structure d’un bus

Composant 1 Composant 2 Composant 3

données

adresses

contrôle

Un bus consiste typiquement de trois types de signaux :

• Données : les informations échangées pas les composants.

• Adresses : pour identifier un composant.
• Contrôle : signaux qui régissent la communication entre les composants.

• Bus parallèle : plusieurs signaux de données.

• Bus série : un seul signal de données.
Architecture des ordinateurs 212
Bus synchrone
• Les signaux de contrôle incluent une horloge qui régit la communication.
• Exemple : Le processeur demande à la mémoire de lui fournir une donnée située à une
certaine adresse

Horloge

Adresse Adresse
valide

Donnée
Donnée valide

Architecture des ordinateurs 213

Bus asynchrone
• Différents signaux de contrôle et protocole de handshaking.
• Exemple : Le processeur demande au disque de lui fournir une donnée.

Adresse Adresse valide

Adresse prête

Adresse lue

Donnée Donnée valide

Donnée prête

Donnée lue

Architecture des ordinateurs 214

Bus synchrone Vs Bus asynchrone
• Bus synchrone.
– Avantages :
• moins de signaux de contrôle.
• rapide.
– Désavantages :
• tous les composants connectés au bus doivent utiliser la même fréquence d’horloge.
• la longueur du bus doit être limitée.

• Bus asynchrone.
– Avantages :
• peut connecter des composants ayant une rapidité de fonctionnement différente.
• sa longueur ne pose pas de problèmes.
– Désavantages :
• plus lent.
• beaucoup de signaux de contrôle.

Architecture des ordinateurs 215

Standards de bus
• Bus d’extension (expansion bus).
– liés à un connecteur d’extension (slot) permettant de connecter des composants
(carte graphique, carte son, carte réseau).
– différents standards : ISA, EISA, PCI, PCIe.
• Interfaces de disque.
– utilisés pour connecter des disques.
– différents standards : ATA, IDE, SCSI, SATA
• Bus externes.
– utilisés pour connecter des composants externes (imprimantes, écrans…)
– différents standards : LPT (imprimante), PS/2 (clavier/souris), USB.
• Bus de communication.
– utilisés pour connecter deux ou plusieurs systèmes.
– différents standards : LPT, RS232C, Ethernet.

Architecture des ordinateurs 216

Carte mère

source : [Link]

Architecture des ordinateurs 217

Bus partagé ou bus point à point
• Bus partagé : plusieurs composants sont connectés sur un même bus.
– choix de préférence dans les ordinateurs anciens.
• Bus point à point : un bus relie deux composants.
– choix de préférence dans les ordinateurs modernes.
• Dans un bus partagé :
– un composant est le maître (master) du bus quand il initie un transfert de données.
– un composant est esclave (slave) s’il ne reçoit que des données.
– il faut un mécanisme d’arbitrage pour éviter que deux composants deviennent
maîtres du bus au même temps (éviter les conflits).
– arbitrage centralisé : un dispositif (arbitre) du bus décide qui peut devenir maître à
un moment donné.
– arbitrage décentralisé : les composants connectés au bus suivent un protocole pour
décider qui peut devenir maître à un moment donné.
– il faut assurer la vivacité : un composant ne doit pas attendre à l’infini pour pouvoir
initier un transfert de données.
– différents techniques (on ne les verra pas…).

Architecture des ordinateurs 218

Bus ISA et VL-Bus
• Bus ISA : Industry Standard Architecture.
– créé en 1981 par IBM.
– bus parallèle (8 ou 16 bits).
– bus synchrone (4.77MHz - 6MHz - 8MHz).
– bus partagé par au plus 6 composants.
– survécut plusieurs années (compatibilité et rapidité satisfaisante avant les
applications multimédias).
• VL-Bus : Video Electronics Standards Association.
– créé en 1992 par VESA.
– bus parallèle (32 bits).
– bus synchrone (25 – 40 MHz).
– bus partagé par au plus 3 composants.
– aussi rapide que la CPU.
– connexion directe avec la CPU….
– ….mais limitation sur le nombre de composants.
– utilisé surtout pour connecter des cartes graphiques.

Architecture des ordinateurs 219

PCI
• PCI bus : Peripheral Component Interconnect.
– créé en 1992 par Intel.
– bus parallèle (32 ou 64 bits).
– bus synchrone (33MHz ou 66MHz).
– bus partagé au plus par 5 composants.
– utilise une puce (le pont, ou bridge) pour se connecter à la CPU.

CPU Mémoire

bridge Péripherique

Bus PCI

Péripherique Péripherique Péripherique

Architecture des ordinateurs 220

 PCI-X
• PCI-X : PCI eXtended.
– similaire à PCI.
– gestion des transferts de données différente.
– plus rapide que PCI.
Bus Vitesse du bus Bande passante du bus Nombre de composants
PCI 32-bit 33 MHz 132MB/s 4-5
PCI 32-bit 66 MHz 264 MB/s 1-2
PCI-X 32-bit 66 MHz 264 MB/s 4
PCI-X 32-bit 133 MHz 532 MB/s 1-2
PCI-X 32-bit 266 MHz 1.064 GB/s 1
PCI-X 32-bit 533 MHz 2.132 GB/s 1
pour les bus à 64 bits, il faut doubler les valeurs de la bande passante.

• Désavantages avec PCI et, en général, tous les bus parallèles.

– Plus l’horloge est rapide, plus les interférences électromagnétiques sont fortes.
– Les fils du bus n’ont pas la même longueur : délai de propagation (time skew).
– Au final : un bus parallèle n’est pas plus rapide que un bus série (!)

Architecture des ordinateurs 221

Retour aux bus série
• Retour aux bus série (pensez à USB…).
– transmission d’un bit à la fois.
• Plus simples à réaliser.
– deux fils pour transmettre des données.
– deux fils pour recevoir des données.
– technique pour éliminer les interférences : transmission différentielle.

source : [Link]

• Pas de délai de propagation : on peut incrémenter la fréquence de l’horloge.

• Communication full-duplex.

Architecture des ordinateurs 222

 PCI Express
• PCIe : PCI Express.
– créé en 2004 par Intel, Dell, HP et IBM.
– Bus série.
– Bus synchrone (2.5GHz – 16 GHz).
– connexion point à point.
chemin (lane)

Composant 1 Composant 2

chemin (lane)

• PCIe x1, x2, x4, x8, x12, x16, x32 : nombre de chemins.
• Chaque « paquet » de données est envoyé sur plusieurs chemins.
• Chaque fil est indépendant des autres (!) : sinon on aurait une transmission
parallèle.
Architecture des ordinateurs 223
PCI Express
• Dans PCIe l’horloge est codée avec les données.
– une partie des bits des données est utilisée pour l’horloge.
– PCIe 1.0 et PCIe 2.0 utilisent le codage 8b/10b.
• 8 bits de données sont codés sur 10 bits.
– PCI 3.0, 4.0, 5.0 utilisent le codage 128b/130b.
• 128 bits de données sont codés sur 130.

Bus Codage Horloge Bande passante du bus (x1) Année

PCIe 1.0 8b/10b 2.5 GHz 250 MB/s 2003
PCIe 2.0 8b/10b 5 GHz 500 MB/s 2007
PCIe 3.0 128b/130b 8 GHz 984.6 MB/s 2010
PCIe 4.0 128b/130b 16 GHz 1.969 GB/s 2017
PCIe 5.0 128b/130b 32 GHz (ou 25GHz?) 3,938 GB/s 2019

Avec PCIe 4.0 x16, nous obtenons une bande passante de 31.5 GB/s!

Architecture des ordinateurs 224

 Structure d’un ordinateur ancien

Mémoire CPU

Bus de système

Carte
Péripherique Péripherique Péripherique
graphique

Architecture des ordinateurs 225

 Structure d’un ordinateur moderne

Mémoire CPU
Carte
graphique

Péripherique Chipset Péripherique

Péripherique
Architecture des ordinateurs 226
 Entrées/Sorties dans un ordinateur

Mémoire CPU
Carte
graphique

Coupleur Chipset Coupleur

Coupleur

Architecture des ordinateurs 227

 Entrées/Sorties dans un ordinateur

Entrées/Sorties mappées en mémoire

(Mémory-mapped I/O) :
CPU
● Une partie des adresses mémoire
indiquent des registres des coupleurs.

● Utilisation des instructions de

lecture/écriture mémoire.
Chipset

Registre de
contrôle/ état
Circuits Péripherique
Données

Architecture des ordinateurs 228

Exemple : clavier

CPU

Chipset

registre d’état registre sortie registre entrée

port entrée port sortie

Architecture des ordinateurs 229

 Interaction processeur – périphérique
• Un périphérique permet à l’utilisateur d’intéragir avec l’ordinateur.
– clavier, souris….
• Les actions faites sur un périphérique donnent lieu à des événements.
– appuyer sur une touche du clavier
• Un événement doit déclencher une réaction de l’ordinateur (du processeur)
– visualiser sur l’écran le caractère correspondant à la touche appuyée.
• Le processeur ne sait pas quand un périphérique génère un événement.
• Première solution : attente active (polling)
• Le processeur contrôle périodiquement si
le périphérique a généré un événement.
• Problème : le processeur perd son temps à
attendre.

Architecture des ordinateurs 230

Interruptions
• Les interruptions sont un mécanisme permettant à un dispositif (tel qu’un
périphérique) de forcer le processeur à interrompre l’exécution du
programme en cours afin de s’occuper d’une autre tâche.
– L’utilisateur appuie sur une touche, une interruption est déclenchée afin que le
processeur lise le caractère et le visualise.
– Le processeur demande des données au disque dur. Quand les données sont prêtes,
le disque dur déclenche une interruption.
• Les interruptions sont implémentées au niveau matériel.

Architecture des ordinateurs 231

 Prise en compte d’une interruption
• A la fin de l’exécution de chaque instruction le processeur vérifie si le signal IRQ est activé.
• Si IRQ est activé et les interruptions ne sont pas masquées, il prend en compte l’interruption.
• Sauvegarde le contexte d’exécution (CO, registre état et autres registres utilisés par le
programme en cours).
• Il charge le PC avec l’adresse de la routine de traitement d’interruption (vecteur d’interruption).

Programme Routine de
en cours traitement d’IT
Sauvegarde du
IRQ
contexte
d’exécution
Restauration du
contexte
d’exécution Fin traitement IT
Architecture des ordinateurs 232
Timers
• Les timers sont des dispositifs qui permettent de compter des durées
temporelles.
• Un timer permet de déterminer le lancement d’une tâche dans un délai
précis, ou la répétition d’une tâche à intervalles réguliers.
• Le timer peut être programmé pour déclencher une interruption
périodiquement
– Lorsqu’une interruption se produit, une routine de traitement de l’interruption est
appelée.

Architecture des ordinateurs 233

Pyboard

Utilise un microcontrôleur STM32F405RG

• CPU : ARM 32-bit 168 MHz.

• SRAM 192 KB.
• 1 MB mémoire Flash.

Exercices en faire en BE :

• Connecter deux boutons et une LED à la Pyboard.

• Ecrire un programme qui allume la LED lorsqu’on appuie
sur le bouton vert et l’éteint lorsqu’on appuie sur le bouton
rouge.
• Par scrutation et par interruption…
• Faire clignoter la LED en utilisant un timer.

Architecture des ordinateurs 234

Pyboard – MicroPython

• On n’utilisera pas le langage d’assemblage!

• Utilisation de MicroPython.
• Implémentation d’un interpréteur Python (en C) qui s’exécute sur un
microcontrôleur.
• Permet d’avoir le contrôle sur le matériel du microcontrôleur sans devoir
utiliser un langage de bas niveau.

import pyb

bouton_vert = [Link]("X1")
bouton_vert.init([Link], [Link].PULL_UP)
[Link]([Link].OUT_PP)

def interruption_vert(ligne):
allume_led()

irq_vert = [Link](bouton_vert, [Link].IRQ_FALLING,

[Link].PULL_UP, interruption_vert)

Architecture des ordinateurs 235

CHAPITRE VII
Notions avancées sur les
processeurs

Architecture des ordinateurs

CISC Vs. RISC
• Deux philosophies de réalisation d’un processeur.

• CISC : Complex Instruction Set Computer.

– Une instruction peut exécuter plusieurs opérations à la fois.
– Le jeu d’instructions d’un processeur CISC est très riche.
– Idée : simplifier le codage en langage d’assemblage (combler le fossé sémantique).
– Minimiser le nombre d’instructions d’un programme en langage d’assemblage.
– Exemple de processeur CISC : Intel x86.

• RISC : Reduced Instruction Set Computer.

– Le jeu d’instructions d’un processeur RISC est petit.
– Idée : chaque instruction machine est exécutée en un seul cycle d’horloge.
– Minimiser le nombre de cycles par instruction.
– Exemple de processeur RISC : PowerPC

Architecture des ordinateurs 237

CISC Vs. RISC
• On veut multiplier deux valeurs a, b qui sont stockées en mémoire.
• Un processeur CISC aurait une instruction MULT a, b qui :
– cherche les valeurs en mémoire.
– les sauvegarde dans deux registres du processeur.
– applique la multiplication.
– sauvegarde le résultat en mémoire.
• Sur un processeur RISC, la même opération serait exécutée avec plusieurs
instructions.
– LOAD r1, a
– LOAD r2, b
– PROD r2, r1, r2
– STORE r2, a

Architecture des ordinateurs 238

CISC Vs. RISC
• À première vue, l’approche CISC semble plus rapide.
– une seule instruction.
– moins de mémoire RAM nécessaire.
– compilation d’un langage de haut niveau plus facile.
• Mais la structure d’un processeur CISC est plus complexe.
– le séquenceur est généralement micro-programmé.
• L’instruction CISC nécessite de plusieurs cycles d’horloge.
• Chaque instruction RISC nécessite d’un seul cycle d’horloge.
– même temps d’exécution qu’un programme CISC
• La structure d’un processeur RISC est plus simple.
– le séquenceur peut être cablé (exécution plus rapide).
– pipelining possible.
• Un programme RISC occupe plus de mémoire.
– mais le coût de la mémoire ne cesse de baisser....

Architecture des ordinateurs 239

Caractéristiques d’un processeur RISC
• Chaque instruction est exécutée en un cycle d’horloge.

• Beaucoup de registres.
– pour minimiser les interactions avec la mémoire.
– dans un processeur CISC moins de registres.

• Format des instructions fixe.

– le décodage est plus simple, donc plus rapide.
– dans un processeur CISC les instructions ont un format variable.

• Modes d’adressage limités.

• Séquenceur cablé.

Architecture des ordinateurs 240

 RISC – Pipelining

Analogie de la lessive

source : [Link]

Architecture des ordinateurs 241

RISC – Pipelining
• La phase de fetch est une source de ralentissement de la vitesse d’exécution
d’une instruction.
• Pipelining : commencer le fetch de l’instruction suivante lorsqu’on décode
l’instruction courante
Temp
s
Instruction 1 F D E
Instruction 2 F D E
Instruction 3 F D E
Instruction 4 F D E
Instruction 5 F D E

pas de pipeline F D E F D E F D E F D E F D E
Architecture des ordinateurs 242
 RISC – Pipelining
…
.
b end F D E La valeur du CO
change…
ldr r0, r1 F D E …mais trop tard!!
l’instruction suivante est
exécutée
mov r2, r0 F D E
ldr r1, r2 F D E

…
.

Architecture des ordinateurs 243

 RISC – Pipelining
…
.
b end F D E La valeur du CO
change…
ldr r0, r1 F D E …mais trop tard!!
l’instruction suivante est
exécutée
mov r2, r0 F D E
ldr r1, r2 F D E

… • Une technique appelée « prédiction de branchement» (branch prediction) est

utilisée.
. • Le processeur fait un pari sur le résultat d’un branchement.
• Si son pari est correcte, l’exécution procède.
• Sinon il faut éviter que les instructions récupérées modifient les registres.
• Différentes techniques de branchement (statiques ou dynamiques).

Architecture des ordinateurs 244

RISC – Pipelining
…
.
ldr r0, r2 F D E r0 est modifié

…r0 est lu avant

add r0, r1, r0 F D E modification
mov r5, r6 F D E
mov r3, r4 F D E
…
.

Architecture des ordinateurs 245

 RISC – Pipelining
…
.
ldr r0, r2 F D E r0 est modifié

…r0 est lu avant

mov r5, r6 F D E modification
mov r3, r4 F D E
add r0, r1, r0 F D E
…
.
• Une technique appelée « ordonnancement du code » (code reordering) est utilisée.
• C’est le compilateur qui s’en charge.
• Le compilateur peut détecter les dépendances dans le code.

Architecture des ordinateurs 246

Machine monoprocesseur
• Les ordinateurs anciens avaient seulement un processeur.

• Un processeur peut exécuter un seul programme à la fois.

– le processeur a un seul compteur ordinal (CO).

• Pourtant on peut lancer plusieurs applications même sur les ordinateurs

monoprocesseur.
– écrire un texte et écouter la musique.

• Comment un ordinateur monoprocesseur arrive à gérer plusieurs

applications?

• La réponse est le système d’exploitation.

Architecture des ordinateurs 247

Machine monoprocesseur
Etats d’un processus (programme en exécution).

E E/S A

Bloqué Prêt
Actif
(en cours d’exécution)
(en attente de la fin (en attente du
d’une entrée/sortie, de la processeur)
Un seul (par processeur)
disponibilité d’une
à un instant donné
ressource...)

L’ordonnanceur (scheduler) gère les changements d’états

Architecture des ordinateurs 248
 Machine monoprocesseur

Terminaison

Actif
Fin du quantum Demande d’entrée/sortie
ou de ressource

Suppression

Élection

Prêt Bloqué

Naissance
Fin d’entrée/sortie
ou ressource disponible
Architecture des ordinateurs 249
Machine multiprocesseur

Mémoire E/S

cache cache cache

CPU 1 CPU 2 CPU 3

Architecture des ordinateurs 250

 Processeur multi-cœur
Mémoire E/S

CPU

Cache L3

Cache L2 Cache L2 Cache L2

Cache L1 Cache L1 Cache L1 Cache L1 Cache L1 Cache L1
Core 1 Core 2 Core 3

Architecture des ordinateurs 251

 Exemple : Intel Core i5-4278U (Haswell)
Mémoire E/S

CPU

L3 cache, 3MB, 12-associatif

L2 cache, L2 cache, L2 cache, L2 cache,

256KB, 256KB, 256KB, 256KB,
8-associatif 8-associatif 8-associatif 8-associatif

L1 cache (d), L1 cache (d), L1 cache (i), L1 cache (i), L1 cache (d), L1 cache (d), L1 cache (i), L1 cache (i),
32KB, 32KB, 32KB, 32KB, 32KB, 32KB, 32KB, 32KB,
8-associatif 8-associatif 8-associatif 8-associatif 8-associatif 8-associatif 8-associatif 8-associatif

Core 1 Core 2

Architecture des ordinateurs 252

Exemple : Intel Core i5-4278U (Haswell)

source: Desktop 4th Generation Intel® CoreTM Processor Family, Desktop Intel® Pentium® Processor Family, and Desktop Intel® Celeron®
Processor Family, Datasheet – Volume 1 of 2

Architecture des ordinateurs 253

Exemple : Intel Core i5-4278U (Haswell)

source : Intel® 64 and IA-32 Architectures Software Developer’s Manual, Combined Volumes: 1, 2A, 2B, 2C, 2D, 3A, 3B, 3C, 3D and 4

Architecture des ordinateurs 254

Exemple : Intel Core i5-4278U (Haswell)

source : Intel® 64 and IA-32 Architectures Software Developer’s Manual, Combined Volumes: 1, 2A, 2B, 2C, 2D, 3A, 3B, 3C, 3D and 4

• Prefix : Change le comportement d’une instruction.

• Ex.: LOCK prefix → accès exclusif à la mémoire partagée
• Opcode : code opération.
• ModR/M : opérandes et modes d’adressages.
• SIB : mode d’adressage supplémentaire (indexé).
• Displacement : Adressage relatif
• Immediate : spécification d’une valeur constante.

Architecture des ordinateurs 255

Exemple : Intel Core i5-4278U (Haswell)

source : Intel® 64 and IA-32 Architectures Software Developer’s Manual, Combined Volumes: 1, 2A, 2B, 2C, 2D, 3A, 3B, 3C, 3D and 4

• Prefix : Change le comportement d’une instruction.

• Ex.: LOCK prefix → accès exclusif à la mémoire partagée
• Opcode : code opération.
• ModR/M : opérandes et modes d’adressages.
• SIB : mode d’adressage supplémentaire (indexé).
• Displacement : Adressage relatif
• Immediate : spécification d’une valeur constante.

Architecture des ordinateurs 256

Exemple : Intel Core i5-4278U (Haswell)
int moyenne(int a, int b, int c, int d, int e, int f, int g, int h)
{
return (a+b+c+d+e+f+g+h)/8;
_moyenne: pushq %rbp
}
movq %rsp, %rbp
addl%esi, %edi
addl%edx, %edi
addl%ecx, %edi
addl%r8d, %edi
addl%r9d, %edi
addl16(%rbp), %edi
addl24(%rbp), %edi
movl %edi, %eax
sarl $31, %eax
shrl $29, %eax
addl%edi, %eax
sarl $3, %eax
popq %rbp
retq

Architecture des ordinateurs 257

CHAPITRE VIII
Aperçu de l’histoire de
l’informatique

Architecture des ordinateurs

Calculateurs mécaniques (1642 - 1945)
• Première calculette idée par Blaise Pascal (1642)
– Seulement additions et soustractions.
• Machine analytique inventée par Charles Babbage (1834)
– Premier ordinateur « general purpose »
• Quatre composants:
– Un moulin, pour faire les calculs (le processeur)
– Un magasin, pour stocker les résultats (la mémoire)
– Lecteur de cartes perforées (dispositif d’entrée)
– Imprimante (dispositif de sortie)
• Les programmes étaient écrites sur des cartes
perforées
– Ada Augusta Lovelace première programmeuse.

Architecture des ordinateurs 259

ENIAC, premier ordinateur (1946)
• Inventé par Eckert et Mauchley
• 18.000 tubes électroniques, 1.500 relais
• Formation d’un programme par des câbles.

Relais + tubes

Architecture des ordinateurs 260

Histoire - EDVAC, archit. Von Neumann (1947)
• Représentation d’un programme sous forme digitale (et binaire).
• Mémorisation du programme.
• Architecture sur laquelle les ordinateurs modernes sont basés.

Architecture des ordinateurs 261

 La génération transistors (1955 - 1960)
• Transistor : dispositif semi-conducteur utilisé comme un interrupteur dans les
circuits logiques
• Inventé en 1948 : John Bardeen, Walter Brattain, William Shockley (Bell Labs).

TX-0, premier ordinateur à transistors (MIT) - 1955

DEC PDP-1 (1960)

IBM 7090 (1959) IBM 7094 (1962)

Architecture des ordinateurs 262

La génération transistors (1955 - 1965)

CDC 6600 (1964) – Premier

superordinateur scientifique
(Seymour Cray)

Architecture des ordinateurs 263

 La génération circuits intégrés (depuis 1965)
• Circuit intégré : composant électronique intégrant des circuits électroniques
sur une puce de matériel semi-conducteur (silicium)
– Robert Noyce, 1958, Fairchild Semiconductor.
• Possibilité de placer des dizaines de transistors sur une seule puce.
– ordinateurs moins encombrants.

• 13 modèles d’ordinateurs. Concept de famille.

• 14 000 exemplaires vendus.
• Multiprogrammation : plusieurs programmes en
mémoire au même temps.
• Capacité d’émulation des anciens ordinateurs IBM.

IBM 360 (1965) – première famille d’ordinateurs

Architecture des ordinateurs 264

 La génération circuits intégrés (depuis 1965)

DEC PDP-11 (1970) – 600 000

unités vendues

DEC PDP-8 (1965) – 50 000 unités

vendues DEC VAX (1978) – Premier super
mini-ordinateur (32 bits)

Architecture des ordinateurs 265

La génération circuits intégrés (depuis 1965)

Architecture des ordinateurs 266

La génération circuits intégrés (depuis 1965)
• VLSI (Very Large Scale Integration) : intégration de millions de transistors
sur une puce unique (~1980).
– ordinateurs plus petits et beaucoup moins chers.
• Concept de micro-ordinateur : simple, économique, mais puissant

• IBM Personal Computer : 12 Août 1981

• CPU : Intel 8080 4.77Mhz
• Mémoire : 16kB ~ 256 kB
• Système d’exploitation : Microsoft DOS
• Prix : $1 565 (~$5 000 aujourd’hui)
• 100 000 unités vendues seulement en 1981
• Schémas des circuits publiés
– d’autres clones sont produits, beaucoup moins chers

Architecture des ordinateurs 267

 La génération circuits intégrés (depuis 1965)

Osborne 1 (1981) – Premier ordinateur portable

(10,7 Kg)
Apple Lisa (1981) – Premier ordinateur
doté d’une interface graphique.

Apple Macintosh (1984) – Successeur de

Lisa, plus performant

Architecture des ordinateurs 268

 Ubiquitous Computing

Apple Newton (1993) – Premier ordinateur

de poche Compaq iPAQ 3630 (2000)
HP iPAQ HW910

Apple iPad (2010)

Apple iPhone (2007)

Architecture des ordinateurs 269