View
5
Download
0
Category
Preview:
Citation preview
Architecture des ordinateurs
L’3 EFREI - 2009/2010N. Sicard
© EFREI 2009 - Nicolas Sicard
Architecture des ordinateurs
Architecture : “organisation des éléments composant un système informatique”
Ordinateur : “machine électronique de traitement numérique de l’information, exécutant à grande vitesse les instructions d’un programme enregistré”
Petit Robert
2
© EFREI 2009 - Nicolas Sicard
“People who are really serious about software should make their own hardware”
Alan Kay
3
© EFREI 2009 - Nicolas Sicard
Pourquoi ?
Architectures spécialisées / embarquées
Programmation des systèmes d’exploitation
Optimisations logicielles : 1 à 2 ordres de grandeur
Nouvelles architectures : multi-cœurs / reconfigurables / GPGPU
4
© EFREI 2009 - Nicolas Sicard
Références
Cours d’architecture des ordinateurs L2 de N. Flasque (EFREI)
Cours d’architecture des ordinateurs de Christophe Fiorio (Polytech’ Montpellier)
Wikipedia (Architecture des ordinateurs)
Architecture des ordinateurs : une approche quantitative - Henessy/Patterson - Vuivert / 3ème édition
Architecture des ordinateurs - Andrew Tanenbaum - Pearson Education
5
© EFREI 2009 - Nicolas Sicard
Petit historique
XXe
XIXe
Von Neumann (1944)
Logiquemathématique
Boole (1850)
Shannon
Turing (1940)
MécaniqueAutomatique
ÉlectromécaniqueÉlectronique
ENIAC (1944)
Babbage (1834)
Le transistor (Bell Labs, 1947)
6
© EFREI 2009 - Nicolas Sicard
Schéma général
Unité centrale de traitement (CPU)
Mémoirecentrale
(principale)
Unité de commande
Unité arithmétique & logique
(UAL)
Reg
istr
es
Périphériques
E/S
programme
➁
➀
données
➂
7
© EFREI 2009 - Nicolas Sicard
Principe de fonctionnement
1. Chargement du programme et des données dans la mémoire centrale depuis un périphérique
2. Chargement séquentiel des instructions du programme de la mémoire vers l’unité de commande
3. Analyse de l’instruction par l’unité de commande / transmission à l’UAL pour traitement
4. Traitement de l’instruction par l’UAL (avec éventuellement échanges avec la mémoire ou les périphériques)
8
© EFREI 2009 - Nicolas Sicard
Plan du cours
L’information
L’unité de traitement
La hiérarchie mémoire
Les bus
9
© EFREI 2009 - Nicolas Sicard
L’information
10
© EFREI 2009 - Nicolas Sicard
Codage de l’information
Ordinateur = “machine électronique de traitement numérique de l’information...”
Information de base = le nombre (entier ou réel)
Comment représenter, traiter et stocker un nombre ?
11
© EFREI 2009 - Nicolas Sicard
Représentation > Langage binaire
Alphabet de l’ordinateur = { 0, 1 }
Une lettre = un bit (unité d’information élémentaire)
Un mot = { bits } (un ensemble de bits de taille fixe)
L’information de base est un nombre codé par un mot
- entiers naturels (non signés)
- entiers signés (positifs ou négatifs)
- nombre réel “à virgule” (fixe ou flottante)
12
© EFREI 2009 - Nicolas Sicard
Langage binaire > Rappel sur les bases
b Nom Chiffres
2 Binaire { 0 , 1 }
8 Octale { 0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 }
10 Décimale { 0,1,2,3,4,5,6,7,8,9 }
16 Hexadécimale {0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F}
Tout nombre P peut s’écrire dans une base b quelconque sous la forme :
anan−1 . . . a0, a−1 . . . a−m
avec m, n > 0 et 0 ≤ ai < b ( ai = chiffre )
base puissance de 2
13
© EFREI 2009 - Nicolas Sicard
Rappel sur les bases > Conversions
Conversion de la base b vers la base 10 :
La valeur de P en base 10 est donnée par :
P =n�
i=−m
aibi
= anbn + an−1bn−1 + . . . + a0b
0 + a−1b−1 + . . . + a−mb−m
Exemple : valeur de P = (1011,110)2 en base 10 ?
Chiffres ai
Valeurs des ai
Puiss. de b (i)
bi
a3 a2 a1 a0 , a-1 a-2 a-3
1 0 1 1 , 1 1 0
3 2 1 0 -1 -2 -3
8 4 2 1 0.5 0.25 0.125
P = 1x8 + 0x4 + 1x2 + 1x1 + 1x0,5 + 1x0,25 + 0x0,125 = 11,7510
anan−1 . . . a0, a−1 . . . a−m
14
© EFREI 2009 - Nicolas Sicard
Rappel sur les bases > Conversions > Exemples
Chiffres ai
Valeurs des ai
Puiss. de b
bi
a2 a1 a0 , a-1 a-2 a-3
6 2 5 , 7 0 3
2 1 0 -1 -2 -3
64 8 1 0.125 0.015625 0.001953125
Octal : (625,702)8 => base 10
625,7028 = 6x64 + 2x8 + 5x1 + 7x0,125 + 0x0,015625 + 3x0,001953125= 405,8789062510
Hexadécimal : (F23,A0)16 => base 10
Chiffres ai
Valeurs des ai
Puiss. de b
bi
a2 a1 a0 , a-1 a-2
F 2 3 , A 0
2 1 0 -1 -2
256 16 1 0.0625 0.00390625
F23,A016 = 15x256 + 2x16 + 3x1 + 10x0,0625 + 0x0,00390625= 3875,62510
15
© EFREI 2009 - Nicolas Sicard
Rappel sur les bases > Conversions > Exemples
Conversions entre bases puissances de 2
BinaireBinaire
Octal
BinaireBinaire
Hexa
1 0 0 1 1 1 , 1 0 1 1 0 1 1
100100100 111111111 , 101101101 101101101 100100100
444 777 , 555 555 444
1 0 0 1 1 1 , 1 0 1 1 0 1 1
.0010.0010.0010.0010 .0111.0111.0111.0111 , 1011101110111011 .0110.0110.0110.0110
2222 7777 , BBBB 6666
Il suffit de regrouper ou séparer les bits :
‣ 3 bits = un chiffre octal
‣ 4 bits = un chiffre hexadécimal
Exemple :
16
© EFREI 2009 - Nicolas Sicard
On divise le nombre en base 10 successivement par b tant que le quotient est différent de 0. Les restes successifs (< b) constituent la suite des
chiffres en base b.
Rappel sur les bases > Conversions > Exemples
Conversion depuis la base 10 vers la base b:
Exemple : Nombre Division Quotient Reste
163 /2 = 81 1
81 /2 = 40 1
40 /2 = 20 0
20 /2 = 10 0
10 /2 = 5 0
5 /2 = 2 1
2 /2 = 1 0
1 /2 = 0 1Lecture
du résultat
16310 = 101000112
17
© EFREI 2009 - Nicolas Sicard
Langage binaire > Mots
Taille (en bits) Nom français English name Nb de valeurs représentables
1 bit bit 2
4 quartet nibble 24 = 16
8 octet byte 28 = 256
16 mot de 16 bits half-word 216 = 65536
32 mot de 32 bits (32 bits) word 232 = 4,29.109
64 mot de 64 bits (64 bits) word 264 = 1,84.1019
Espace de représentation pour des entiers naturels p (avec n bits) :
0 = (0...0)2 ≤ p ≤ 2n-1 = (1...1)2
18
© EFREI 2009 - Nicolas Sicard
Langage binaire > Poids des mots
Bits de poids fort / faible (sur N bits) :
1 0 0 1 1 1 1 0 0 1 0 1 0 0 1 1
Octets de poids fort / faible :
bit de poids fort(Most Significant Bit)
x2N-1
1 0 0 1 1 1 1 0 0 1 0 1 0 0 1 1
octet de poids fort : x2N/2 octet de poids faible : x20
On peut généraliser aux mots de poids fort / faible dans les structures plus grandes
bit de poids faible(Least Significant Bit)
x20
19
© EFREI 2009 - Nicolas Sicard
Langage binaire > Addition simple
Exemple : additionner 18 et 27 en binaire
1
1 82 74 5
Rappel en décimal :
1 1
1 0 0 1 01 1 0 1 1
1 0 1 1 0 1
En binaire :
1 0 0 1 01 1 0 1 1
2
2
4 510
20
© EFREI 2009 - Nicolas Sicard
Langage binaire > Entiers signés
Bit de poids fort : bit de signe = 0 (positif) ou 1 (négatif)
0xxxxxxxx xxxxxxxx = (-1)0.p = +p
1xxxxxxxx xxxxxxxx = (-1)1.p = -p
Espace de représentation (restent n-1 bits)
-2n-1+1 ≤ p ≤ +2n-1-1
Problème : double représentation de 0
0 | 0...0 = +0
1 | 0...0 = -0
p
21
© EFREI 2009 - Nicolas Sicard
Entiers signés > Bit de signe simple
Problème au niveau des opérations (sur 5 bits) :
1 1 1
0 1 1 0 0+ 1 1 1 0 0
[1] 0 1 0 0 0
1 2-12
+8 ?!!
Représentation non consistante : phase d’interprétation de
l’instruction en fonction du signe (compliqué)
22
© EFREI 2009 - Nicolas Sicard
Entiers signés > Complément à 2
Principe général en base b (complément à b) :
Pour un nombre N en base b contenant n chiffres (n fixe), on appelle
complément à b de N le nombre N = bn - N.On code la valeur -N par N.
Exemple en base 10 sur 5 chiffres :
Complément de 0 = 105 - 0 = (1)00000 = 00000 (tronqué à 5 chiffres) = 0=> une seule représentation de 0 = 00000
Opérations sur n chiffres (exemple de l’addition) :
-N + N = N + N = (10n - N) + N = 10n = 0si n=1 : -7 + 9 = (101 - 7) + 9 = 3 + 9 = (1)2 = 2 (tronqué à 1 chiffre)
si n=2 : -7 + 9 = (102 - 7) + 9 = 93 + 9 = (1)02 = 2 (tronqué à 2 chiffre)
23
© EFREI 2009 - Nicolas Sicard
Entiers signés > complément à 2
En base 2 (représentation binaire d’un nombre p) :
sur n bits : -p = 2n - p
Obtenir rapidement la représentation de -p à partir de p :
Exemple (sur 5 chiffres) :
−p = 2n − p = (2n − 1) + 1− p
= 1 . . . 1� �� �n
−p + 1
= p + 1 avec p = complémentaire (bit à bit) de p
p = 12 = 011002
-p = p + 1 = 10011 + 1 = 10100
Remarque : -(-p) = 01011 + 1 = 01100 = 12
=> la méthode est valable quelque soit le signe de départ !24
© EFREI 2009 - Nicolas Sicard
Entiers signés > complément à 2
Application sur les opérations (sur 5 bits) :
1 1 1
0 1 1 0 0+ 1 0 1 0 0
[1] 0 0 0 0 0
1 2-12
0
Représentation consistante : pas de phase d’interprétation
supplémentaire pour les nombres signés
25
© EFREI 2009 - Nicolas Sicard
Entiers signés > complément à 2
Autres exemples d’addition (sur 5 bits) :
Représentation consistante : pas de phase d’interprétation
supplémentaire pour les nombres signés8 = 010002 => -8 = 101112+1 = 110002
0 0 1 0 1 [5]
+ 0 1 0 0 0 [8]
0 1 1 0 1 [13]
0 0 1 0 1 [5]
+ 1 1 0 0 0 [-8]
1 1 1 0 1 [-3]
11 1 0 1 1 [-5]
+ 0 1 0 0 0 [8]
1 0 0 0 1 1 [3]
11 1 0 1 1 [-5]
+ 1 1 0 0 0 [-8]
1 1 0 0 1 1 [-13]
5 + 8 :
-5 + 8 : -5 + (-8) :
5 + (-8) :
26
© EFREI 2009 - Nicolas Sicard
Représentation > Autres codes
Toute information doit être codée par des nombres (entiers ou réels) ou par des suites de bits. Par exemple, le texte :
Table des codes ASCII :À chaque caractère est
associé un code entier sur 8
bits (char).
ww
w.cdrumm
ond.qc.ca
27
© EFREI 2009 - Nicolas Sicard
Traitement > Transistors
Source Drain
Grille
La tension électrique appliquée à la grille conditionne le “passage” du courant entre la source et le drain.
Transistor CMOS*
*CMOS = Complementary metal oxide semi-conductor
28
© EFREI 2009 - Nicolas Sicard
Traitement > Le transistor
Source Drain (D)
ouvertAnalogie avec l’interrupteur
0 Volt 2 Volts
Information binaire en un point = potentiel du drain
Interrupteur ouvert : D = 2V = 1
29
© EFREI 2009 - Nicolas Sicard
Traitement > Le transistor
Source Drain (D)
ferméAnalogie avec l’interrupteur
0 Volt 0 Volts
Information binaire en un point = potentiel du drain
Interrupteur fermé : D = 0V = 0
30
© EFREI 2009 - Nicolas Sicard
Traitement > Le transistor
Transistor N
Transistor P
S D
G (2V)
S D
G (0V)
S D
G (2V)
S D
G (0V)
= isolation électrique= conduction électrique 31
© EFREI 2009 - Nicolas Sicard
Transistor > Exemple de l’inverseur
in
out = NON( in )
S D
32
© EFREI 2009 - Nicolas Sicard
Transistor > Exemple de l’inverseur
= isolation électrique
in = 0V = 0
out = 2V = 1
S D
33
© EFREI 2009 - Nicolas Sicard
Transistor > Exemple de l’inverseur
in = 2V = 1
out = 0V = 0
S D
34= isolation électrique
© EFREI 2009 - Nicolas Sicard
Exemple de l’inverseur > Portes logiques
E E
0 1
1 0
Porte logique NON : Table de vérité de la porte NON :
E E
35
© EFREI 2009 - Nicolas Sicard
Traitement > Portes logiques
NAND (non-et) NOR (non-ou)
A B out
0 0 1
0 1 1
1 0 1
1 1 0
A B out
0 0 1
0 1 0
1 0 0
1 1 0
36
© EFREI 2009 - Nicolas Sicard
Traitement > Portes logiques
XOR (ou exclusif)
A B out
0 0 0
0 1 1
1 0 1
1 1 0
OR (ou)
A B out
0 0 0
0 1 1
1 0 1
1 1 1
AND (et)
A B out
0 0 0
0 1 0
1 0 0
1 1 1
37
© EFREI 2009 - Nicolas Sicard
Traitement > Portes logiques
MUX (multiplexeur)
A B S0 out
0 0 0 0
0 0 1 0
0 1 0 0
0 1 1 1
1 0 0 1
1 0 1 0
1 1 0 1
1 1 1 1
A B
S0
out
S0 out
0 A
1 B
L’entrée A ou B est propagée sur la sortie suivant la valeur de la commande S0 :
38
A B
0
out = A
A B
1
out = B
© EFREI 2009 - Nicolas Sicard
Portes logiques > Exemple de l’additionneur
Problème : additionner 18 et 27 avec des transistors
1
1 82 74 5
En décimal :
1 1
1 0 0 1 01 1 0 1 1
1 0 1 1 0 1
En binaire :
opération logique
39
© EFREI 2009 - Nicolas Sicard
Additionneur > Demi-additionneur 1 bit
1 1
1 0 0 1 01 1 0 1 1
1 0 1 1 0 1
En binaire :
opération logique au rang i
Ai Bi Si=Ai+Bi Ri+1
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
A
B
S
Ri+1
A
AiBi
Si
Ri+1
XOR AND demi additionneur40
© EFREI 2009 - Nicolas Sicard
Additionneur > Additionneur 1 bit
Au rang i, il ne faut pas oublier d’ajouter la retenue Ri issue du rang i-1 !
Si = ( Ai + Bi ) + Ri
Il suffit donc de combiner 2 demi-additionneurs :
1/2add1/2
add
Ai
Bi
Ri
S’iSi
Ri+1
Ri+1 = ?
AB S
R
1/2add
41
© EFREI 2009 - Nicolas Sicard
Ai Bi Ri R’i S’i R”i Si Ri+1
0 0 0 0 0 0 0 0
0 0 1 0 0 0 1 0
0 1 0 0 1 0 1 0
0 1 1 0 1 1 0 1
1 0 0 0 1 0 1 0
1 0 1 0 1 1 0 1
1 1 0 1 0 0 0 1
1 1 1 1 0 0 1 1
Additionneur > Additionneur 1 bit
1/2add1/2
add
Ai
Bi
Ri
S’iSi
Ri+1
R”i
R’i
Ai Bi Ri R’i S’i R”i Si Ri+1
0 0 0 0 0 0 0 0
0 0 1 0 0 0 1 0
0 1 0 0 1 0 1 0
0 1 1 0 1 1 0 1
1 0 0 0 1 0 1 0
1 0 1 0 1 1 0 1
1 1 0 1 0 0 0 1
1 1 1 1 0 0 1 1
Si = S’i xor Ri
S’i = Ai xor Bi
R’i = Ai and Bi
R”i = S’i and Ri
Ri = R’i or R”i
+additionneur
Ai
Bi
Ri
Si
Ri+1
42
© EFREI 2009 - Nicolas Sicard
Portes logiques > Additionneur n bits
n additionneurs 1 bit en étage
+A0
B0
R0=0
S0
++
A1
B1
A2
B2
S1
S2
R1
R2
43
1 1 0
1 0 0 1 0
1 1 0 1 1
1 0 1 1 0 1
Ai
Bi
Ri
Si
etc
© EFREI 2009 - Nicolas Sicard
Stockage > Bascules
Bascule RS (principe) :
S R Qn Qn+1
0 0 0 0
0 0 1 1
0 1 X 0
1 0 X 1
1 1 X X
La dernière valeur de sortie est “mémorisée” tant que S et R sont à 0. Sinon, la sortie Q vaut S (la combinaison R=S=1 est interdite).
R
S
Q
Q
44
Qn = Q avant changement de S et RQn+1 = Q après changement de S et R
© EFREI 2009 - Nicolas Sicard
Stockage > Bascules RS > Exemple
Bascule RS (principe) :
n S R Qn Qn+1 action
0 1 0 ? 1 enregistrer 11 0 0 1 1 garde sa valeur
2 0 1 1 0 enregistrer 0
3 0 0 0 0 garde sa valeur
4 1 0 0 1 enregistrer 1
5 0 0 1 1 garde sa valeur
6 0 0 1 1 garde sa valeur
7 0 1 1 0 enregistrer 0
8 0 0 0 0 garde sa valeur
R
S
Q
Q
S R Qn Qn+1
0 0 0 0
0 0 1 1
0 1 X 0
1 0 X 1
1 1 X X
45
© EFREI 2009 - Nicolas Sicard
L’information > Récapitulatif
• Information élémentaire est représentée par un bit. L’ordinateur stocke et manipule des mots (ensemble de bits) de taille fixe.
• Les opérations numériques sont réalisées par des circuits complexes d’opérations logiques élémentaires (portes logiques) basées sur l’utilisation de transistors.
• Les informations élémentaires (bits) sont stockées dans des circuits logiques spécifiques, par exemple des bascules.
46
© EFREI 2009 - Nicolas Sicard
L’unité de traitement (CPU)
47
© EFREI 2009 - Nicolas Sicard
Rappel
Ordinateur = “... exécutant à grande vitesse les instructions d’un programme enregistré.”
• exécutant : unité de calcul (UAL)
• programme : séquence d’instructions exécutables par la machine
• instructions : opérations élémentaires (actions) et opérandes (variables)
• enregistré : mémoire pour stocker les instructions et les données traitées
48
© EFREI 2009 - Nicolas Sicard
Architecture Harvard
Séparation des instructions et des données dans des mémoires distinctes
Unité centrale de traitement (CPU)
Mémoire d’instructions
Mémoire de données
bus
bus
49
© EFREI 2009 - Nicolas Sicard
Architecture Harvard
Séparation des instructions et des données dans des mémoires distinctes
• Avantage : optimisations matérielles (accès mémoires différenciés)
• Avantage : accès mémoire indépendants (simultanés)
• Inconvénient : saturation de la mémoire (pas de compensation possible par la seconde)
• Inconvénient : pas de compilation possible sans mécanisme de transfert de mémoire à mémoire
50
© EFREI 2009 - Nicolas Sicard
Architecture Von Neumann
Instructions et données se partagent la même mémoire
Unité centrale de traitement (CPU)
Mémoire centrale
Bus de données
Bus d’adresses
51
© EFREI 2009 - Nicolas Sicard
Architecture Von Neumann
• Avantage : une seule technologie => standard => baisse des coûts
• Avantage : compensation mémoire (moins de problèmes de saturation)
• Inconvénient : pas d’optimisations matérielles spécifiques possibles
• Inconvénient : pas d’accès mémoire simultanés
Instructions et données se partagent la même mémoire
52
© EFREI 2009 - Nicolas Sicard
Schéma synthétique (Von Neumann)
Unité centrale de traitement (CPU)
Mémoirecentrale
(principale)
Unité de commande
Unité arithmétique & logique
(UAL)
Reg
istr
es
Périphériques
E/S
programme
➁
➀
données
➂
53
© EFREI 2009 - Nicolas Sicard
46 0
23 1
87 2
94 3
... ...
17 N-1
Mémoire (fonctionnement simplifié)
Mémoire de N mots de n bits :
Lecture
Écriture Bus d’adresses
Bus de donnéesadresses
n bits
54
© EFREI 2009 - Nicolas Sicard
Registres (processeur de base)
Registre = petite zone mémoire intégrée à la CPU et accessible “instantanément” par l’UAL et l’unité de commande
‣ PC (Program Counter / Compteur ordinal) : contient l’adresse en mémoire de la prochaine instruction
‣ IR (Instruction Register) : contient l’instruction à traiter
‣ A0 (Memory Address Register) : indique à la mémoire l’adresse à laquelle la prochaine instruction de lecture ou d’écriture doit être effectuée
‣ MBR (Memory Buffer Register) : contient la donnée lue ou à écrire dans la mémoire
‣ D0 : registre de donnée permettant d’effectuer des opérations avec l’UAL (accumulateur). Il existe généralement plusieurs registres de données (D0, D1, D2...)
55
© EFREI 2009 - Nicolas Sicard
Unité de commande
Dirige le fonctionnement de tous les autres éléments par des signaux de commande en utilisant :
le compteur ordinal (PC)
le registre instruction (IR)
le registre de conditions (CCR)
le décodeur : circuit qui détermine l’opération et les opérandes
le séquenceur : circuit ou µ-programme qui active les différents composants
l’horloge : circuit qui émet des impulsions pour synchroniser tous les éléments de l’UC
56
Unité de commande
© EFREI 2009 - Nicolas Sicard
Unité de commande > Instruction C simple
Instruction = action élémentaire que le processeur est capable de traiter en une fois + opérandes (càd. les données à traiter)
a = a + b; /* simple instruction du langage C */
1. Décoder l’instruction (quoi faire ?) et les opérandes (avec quoi?)
2. Chercher la valeur de la variable a depuis la mémoire
3. Chercher la valeur de la variable b depuis la mémoire
4. Additionner localement les valeurs reçues
5. Stocker le résultat obtenu en mémoire, à l’emplacement de a
6. Chercher la prochaine instruction à exécuter depuis la mémoire
/* pas si simple pour une machine... */
57
© EFREI 2009 - Nicolas Sicard
Unité de commande > Exécution d’un programme
Dans tous les cas (dans une architecture de type Von Neumann), le schéma de base est le suivant :
• PC = 0
• Répeter (indéfiniment)
FETCH : Chercher l’instruction se trouvant à l’adresse PCDECODE : Décoder l’instruction
EXECUTE : Exécuter l’instruction
PC = PC+1
On suppose que les instructions du programme sont logées dans l’ordre d’exécution à l’adresse 0 de la mémoire. Le comportement de la machine
Von Neumann se décrit alors simplement par :
58
© EFREI 2009 - Nicolas Sicard
Unité de commande > Séquenceur
• Séquenceur : automate distribuant selon un chronogramme précis les signaux de commande. Deux “écoles” :
‣ câblé : circuit séquentiel complexe avec un sous-circuit pour chaque instruction (activé par le décodeur)
‣ micro-programmé : on remplace le circuit logique par une ROM (séquences de micro-instructions)
• Synchronisation des opérations : horloge
‣ cycle machine = durée d’une impulsion d’horloge
‣ cycle CPU = temps d’exécution d’une action élémentaire
front descendantfront montant
cycle
59
© EFREI 2009 - Nicolas Sicard
Séquenceur > CISC
Complex Instruction Set
Les différentes étapes, appelées micro-instructions, sont exécutées dans la CPU comme un micro-programme. À la compilation, l’instruction C est
traduite par une seule instruction machine de haut niveau.
Avantages : jeu d’instruction de haut niveau, “re-microprogrammation” du CPU pour de nouvelles instructions.
Inconvénients : jeu d’instructions pléthoriques, fréquences d’horloge faibles (circuits complexes), micro-programmes = déboguages !
60
© EFREI 2009 - Nicolas Sicard
Séquenceur > RISC
Reduced Instruction Set
Les différentes étapes sont traduites en autant d’instructions machine au moment de la compilation.
Avantages : jeu d’instructions simple (nombre réduit d’instructions), circuits plus simples donc fréquences de fonctionnement plus rapides,
optimisations fortes au niveau de la compilation, exploitation du pipeline
d’instructions...
Inconvénients : circuits de commande complexes (combinatoire), ajouts d’instructions difficiles, compilation plus complexe, besoin de nombreux
registres ...
61
© EFREI 2009 - Nicolas Sicard
Unité Arithmétique et Logique (UAL)
Circuit logique qui effectue une opération à chaque cycle d’horloge à partir d’opérandes et d’une commande (opération) fournies en entrée. Le résultat de l’opération et certains indicateurs (“flags”) sont produits en sortie.
UAL
horloge
opérandes
commande(opération)
résultat
“flags”
IR
D2
D1
D0/IR
DX
CCR
regi
stre
s
regi
stre
s
62
Unité arithmétique & logique(UAL)
© EFREI 2009 - Nicolas Sicard
UAL > Exemple simple
On considère une UAL capable d’additionner et de complémenter sur 2 bits :
+B0
A0
0
+B1
A1 R
S0S1
?
63
© EFREI 2009 - Nicolas Sicard
UAL > Exemple simple
On considère une UAL capable d’additionner et de complémenter sur 2 bits :
+B0
A0
0
S0
+B1
A1
S1MU
X
C
R
0 0 1 0 1
C A1 A0 B1 B0
Additionner :
0
1
0
64
© EFREI 2009 - Nicolas Sicard
1 1 0 X X
C A1 A0 B1 B0
Complémenter :
UAL > Exemple simple
On considère une UAL capable d’additionner et de complémenter sur 2 bits :
A0
S0
A1
S1MU
X
C
R
0
1
+B0
0
+B1
1
65
© EFREI 2009 - Nicolas Sicard
Instructions > Différents types
• opérations arithmétiques : additions, soustractions, multiplications, divisions...
• opérations logiques : et, ou, non, ou-ex etc.
• contrôles de séquence : branchements conditionnels, appels de procédures...
• transferts de données : de mémoire à registre, de registre à registre, de registre à mémoire
• entrées / sorties
• opérations diverses : décalages, conversion de format, permutations, incrémentations...
66
© EFREI 2009 - Nicolas Sicard
Instructions > Codage
Une instruction est une donnée particulière, codée comme une suite de bits
1 0 0 1 1 1 1 0 0 1 0 1 0 0 1 1
op-code opérande #1 opérande #2 opérande #3
code (valeur entière) de l’opérationà exécuter (addition, chargement
mémoire, test...)
valeurs des opérandes pour l’opération spécifiée
par l’op-code
Une opérande est le plus souvent une adresse (indice de registre ou adresse mémoire) ou une valeur immédiate (constante)
67
© EFREI 2009 - Nicolas Sicard
Instructions > Codage
Une instruction est une donnée particulière, codée comme une suite de bits :
1 0 0 1 1 1 1 0 0 1 0 1 0 0 1 1
op-code A opérande #1 opérande #2 opérande #3
0 0 1 1 1 1 1 0 0 1 0 1
op-code B opérande #1
Selon l’op-code, la structure des opérandes (et même la taille de l’instruction) peut changer :
X X X X
68
© EFREI 2009 - Nicolas Sicard
Instructions > Format
• Problème de la taille des instructions
‣ longueurs fixes ou variables
‣ impact sur la mémoire : taille d’un programme proportionnel à la taille d’une instruction
‣ impact sur les performances : transferts mémoires importants pour les instructions de grande taille
• Conception du jeu d’instructions influencée par les connaissances techniques du moment (évolutions possibles)
• Nombre d’opérations (op-codes) sur n bits (n fixé) = 2n
‣ rigidité : nombres d’opérandes différents selon les instructions
69
© EFREI 2009 - Nicolas Sicard
Instructions > Code-opération expansif (16 bits)
0 0 0 0 A D 1 A D 2 A D 3
1 1 1 0 A D 1 A D 2 A D 3} 15 instructions à 3
adresses
1 1 1 1 0 0 0 0 A D 1 A D 2
1 1 1 1 1 1 0 1 A D 1 A D 2} 14 instructions à 2
adresses (dyadiques)
1 1 1 1 1 1 1 0 0 0 0 0 A D
1 1 1 1 1 1 1 1 1 1 1 0 A D} 31 instructions à 1
adresse (nonadiques)
1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1} 16 instructions sans
adresse
= 76 instructions 70
© EFREI 2009 - Nicolas Sicard
Instructions > Assembleur
Langage de programmation “machine” :
MOVE.W D1 , D0
transférer la valeur (mot entier) du registre D1 dans le registre D0
Exemple d’une instruction 68000 (Motorola) :
L’assembleur propose une syntaxe adaptée au programmeur humain pour écrire un programme en langage “machine”.
0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0
MOVE.W D1 D0
71
© EFREI 2009 - Nicolas Sicard
Instructions > Assembleur > Exemple
MOVE.W #3, D0MULU.W #4, D0ADD.W #5, D0MOVE.W D0, x
x = 3*4 + 5;
Compilateur
Assembleur
0011010101011010010001101000100010111111000101010010100101000011
72
© EFREI 2009 - Nicolas Sicard
Instructions > Notation RTL
M(x) avec x un nombre entier = adresse mémoire x
[R] = contenu du registre nommé R (D0-DN)
[M(x)] = [x] = contenu de la mémoire à l’adresse x
<— = opération d’affectation
Notation synthétique des transferts de données : Register Transfer Language
73
© EFREI 2009 - Nicolas Sicard
Instructions > Modes d’adressage
Différentes façon d’identifier des opérandes :
• Adressage implicite : le code-op identifie automatiquement l’opérande, il n’y a pas de champ adresse (opérande). Par exemple test sur un registre particulier
• Adressage immédiat : la valeur de l’opérande est contenue dans le champ adresse (si le nombre de bits suffit, sinon dans le mot suivant l’instruction)
‣ Exemple : MOV #100, R1 ( [R1] <— 100 )
• Adressage registre : le champ adresse contient le numéro du registre opérande
‣ Exemple : CLR R3 ( [R3] <— 0 )
74
© EFREI 2009 - Nicolas Sicard
Instructions > Modes d’adressage
• Adressage direct : le champ adresse (ou le mot suivant si le nombre de bits n’est pas suffisant) contient l’adresse de l’opérande :
‣ Exemple : MOV 100, R2 ( [R2] <— [M(100)] )
• Adressage indirect : le champ adresse contient l’adresse d’un pointeur (ie. mot en mémoire contenant l’adresse de l’opérande)
‣ Exemple : MOV (R1), R4 ( [R4] <— [ M([R1]) ] )
• Adressage indexé : utile pour manipuler les tableaux par exemple, ce mode permet d’utiliser un registre d’index, auquel est additionné une adresse de base pour obtenir l’adresse de l’opérande
‣ Exemple : MOV R4, 100(R3)+ ( [ M(100+[R3]) ] <— [R4] )
75
© EFREI 2009 - Nicolas Sicard
Instructions > Modes d’adressage
• Adressage relatif : l’adresse de l’opérande est obtenue en additionnant le compteur ordinal au contenu du champ d’adresse
‣ Exemple : instructions de branchement
• Panorama non exhaustif : le 68020 présente près de 50 modes d’adressage différents !
• Certains modes peuvent ralentir l’exécution des instructions (calcul des adresses)
76
© EFREI 2009 - Nicolas Sicard
Assembleur > Exemples 68k
▪! ADDA Addition avec registre d'adresse
Syntaxe: ADDA <AE>, An
Opérande: Mot, Mot long
Addition binaire entre un opérande et le contenu d'un registre An.
CCR Non affecté
Exemple: ADDA.W #$1234, A0 ADDA.L -(A1), A0
77
© EFREI 2009 - Nicolas Sicard
Assembleur > Exemples 68k
▪! ADDI Addition immédiate
Syntaxe: ADDI #<donnée>, <AE>
Opérande: Octet, Mot, Mot long
Addition binaire entre la donnée immédiate et l'opérande de destination.
CCR X: Idem à C V: 1 si débordement N: 1 si résultat<0 C: 1 si retenue Z: 1 si résultat=0
Exemple: ADDI.W #$1234, D0 ADDI.B #$03, (A1)+
78
© EFREI 2009 - Nicolas Sicard
Assembleur > Exemples 68k
▪! CMP Comparaison Registre Dn
Syntaxe: CMP <AE>, Dn
Opérande: Octet, Mot, Mot long
L'Opérande source est soustrait de l'Opérande destination afin de positionner les flags CCR.
CCR X: Non affecté V: 1 si débordement N: 1 si résultat<0 C: 1 si retenue Z: 1 si résultat=0
Exemple: CMP.L D0, D1 CMP.W #$1234, D2 CMP.L -(A1), D0
79
© EFREI 2009 - Nicolas Sicard
Instructions conditionnelles
SÉQUENCE 0
SI (condition vraie) ALORS
{ SÉQUENCE V }
SINON
{ SÉQUENCE F }
SÉQUENCE 1
FauxVrai
Branchement
...SÉQUENCE 0
CONDITION ?
...SÉQUENCE V
...
...SÉQUENCE F
...
...SÉQUENCE 1
...
Instructionsmachine
Programme
© EFREI 2009 - Nicolas Sicard
Instructions conditionnelles
On utilise les opérations arithmétiques (soustraction par exemple) ou des instructions spécifiques de comparaison.
Le résultat est stocké dans le registre de condition CCR (Condition Code Register) :
‣ Bit C (Carry) : retenue sortante lors de la dernière opération
‣ Bit V (oVerflow) : dépassement arithmétique de capacité
‣ Bit Z (Zero) : résultat nul lors de la dernière opération
‣ Bit N (Negative) : résultat négatif lors de la dernière opération
Une condition (vrai ou faux) est souvent issue d’une comparaison :
Les instructions de branchement conditionnel interprètent l’état du registre CCR et changent la valeur du compteur ordinal (PC) en fonction
81
© EFREI 2009 - Nicolas Sicard
Instructions conditionnelles > Exemple 68k
Syntaxe, par exemple: BEQ <étiquette>
Les branchements, ou sauts, sont effectués en fonction du contenu du CCR. Si la condition est vraie, l'exécution du programme se poursuit à l'adresse (PC) + déplacement mentionné par l' étiquette.
Exemple: BEQ $06 BNE LaBas CCR Non affecté
Description: Conditions CCR
BCC: Branchement si retenue à zéro C=0 BCS: Branchement si retenue à un C=1 BEQ: Branchement si égal Z=1 BNE: Branchement si différent Z=0 BGE: Branchement si supérieur ou égal N xor V = 0 BGT: Branchement si supérieur Z + [N xor V] = 0 BHI: Branchement si supérieur C + Z = 0 BLE: Branchement si inférieur ou égal Z + [N xor V] = 1 BLS: Branchement si inférieur ou égal C + Z = 1 BLT: Branchement si inférieur N xor V = 1 BMI: Branchement si négatif N=1 BPL: Branchement si positif N=0 BVC: Branchement si pas de dépassement V=0 BVS: Branchement si dépassement V=1 BT: Branchement si vrai tout le temps BF: Branchement si faux jamais 82
© EFREI 2009 - Nicolas Sicard
Chemin de données > FETCH
a. [A0] <— [PC] // adresse de l’instruction à charger sur le bus
b. [PC] <— [PC] + 1 // incrémentation du compteur ordinal
c. [MBR] <— [ M([A0]) ] // lecture de l’instruction chargée dans le registre MBR
d. [IR] <— [MBS] // copie de la valeur de MBR dans le registre instruction
A0PCa
+1
b
OP-CODE OPERANDE
IR d
MBR
Mémoire (données)
c
83
© EFREI 2009 - Nicolas Sicard
UA
L
D0
g
Chemin de données > EXECUTE (ADD P)
MBR
Mémoire (données)
A0PC
+1
OP-CODE adresse mém. PIR
e. [A0] <— [IR<adresse>]
f. [MBR] <— [ M([A0]) ]
g. [D0] <— [D0] + [MBR]
e
f
Ajouter à D0 la valeur située en mémoireà l’adresse P
84
© EFREI 2009 - Nicolas Sicard
Chemin de données > EXECUTE (STORE P)
Mémoire (données)
A0PC
+1
OP-CODE adresse mém.IR
i
j
UA
L
D0
g
Mettre la valeur de D0 en mémoireà l’adresse P
h. [MBR] <— [D0]
i. [A0] <— [ IR<adresse> ]
j. [M([A0])] <— [MBR]
hMBR
85
© EFREI 2009 - Nicolas Sicard
k. [D0] <— [D0] + [IR<opérande>]
Chemin de données > EXECUTE (ADD #5)
UA
L
MBR
D0
Mémoire (données)
A0PC
+1
OP-CODE opérande=#5IR
Valeurs immédiates : ajouter laconstante 5 à D0
k
86
© EFREI 2009 - Nicolas Sicard
Chemin de données > Instructions conditionnelles
UA
L
MBR
D0
Mémoire (données)
A0PC
OP-CODE OPÉRANDEIR
Unité de Commande
Z N V C
+1
87
© EFREI 2009 - Nicolas Sicard
Autres architectures
• Micro-processeur à registres généraux (plus répandu) : la baisse des coûts de fabrication des composants permet d’inclure plusieurs registres de donnée (8, 16, 32...), chacun pouvant jouer le rôle d’accumulateur.
• Microprocesseur à pile : les valeurs en cours de traitement sont sauvegardées en mémoire dans une pile dont l’adresse de la tête est sauvegardée dans un registre spécial (SP, Stack Pointer). Les opérations PUSH et POP permettent respectivement de ranger ou de retirer une opérande
• Architectures à chargement/rangement : les opérandes sont obligatoirement des indices de registres ou des valeurs immédiates (pas d’adresses mémoire). Les opérations LOAD et STORE permettent respectivement de charger des registres depuis la mémoire et vers la mémoire.
88
© EFREI 2009 - Nicolas Sicard
Processeur mono-cycle
• Principe : traitement d’une instruction en un seul cycle d’horloge
‣ FETCH + DECODE + EXECUTE en un cycle !
‣ toutes les instructions doivent suivre à peu près le même chemin
• UNE instruction = UN ensemble de signaux de contrôle
‣ adapté aux architectures RISC
• Séquenceur réalisé par un circuit logique de décodage
89
© EFREI 2009 - Nicolas Sicard
Processeur mono-cycle > MIPS simplifié
• “Microprocessor without Interlocked Pipeline Stages”
‣ MIPS Technologies (80’)
‣ mise en œuvre de la technologie pipeline d’instructions
• Architecture à chargement / rangement
‣ 32 registres généraux (r0 à r31)
‣ instructions codées sur 32 bits (taille fixe)
‣ mémoire adressable par octets => instructions placées à des adresses mémoire multiples de 4
90
© EFREI 2009 - Nicolas Sicard
MIPS > Jeu d’instructions
• Instructions de type R (Registre) : ne travaillent qu’avec les registres (opérations arithmétiques et logiques)
‣ opcode = code de l’opération
‣ rs = registre source (5 bits), en lecture, fournit une valeur
‣ rt = registre transit (5 bits), en lecture ou écriture, selon l’opcode
‣ rd = registre destination (5 bits), en écriture (reçoit le résultat)
‣ bits 6 à 10 non utilisés
‣ code UAL = nature de l’opération arithmétique ou logique
opcode rs rt rd code UAL
31 26 25 21 20 16 15 11 10 6 5 0
91
© EFREI 2009 - Nicolas Sicard
MIPS > Jeu d’instructions
• Instructions de type I (Immédiat) : une des opérandes de type immédiat
‣ opcode = code de l’opération
‣ rs = registre source (5 bits), en lecture, fournit une valeur
‣ rt = registre transit (5 bits), en lecture ou écriture, selon l’opcode
‣ bits 0 à 15 : une valeur entière ou une adresse mémoire (load/store)
opcode rs rt valeur immédiate
31 26 25 21 20 16 15 0
92
© EFREI 2009 - Nicolas Sicard
Mémoire (instructions)
PC
adresse
instruction
MIPS > Phase FETCH
Remarque : les signaux de contrôle ne sont pas générés (ils le sont à la phase DECODE)
93
© EFREI 2009 - Nicolas Sicard
banc deregistres
valeursimmédiates
31-26
25-21
20-16
15-11
15-0
Séquenceur
C
instruction32 bits
5-0
MIPS > Phase DECODE
opcode rs rt rd code UAL
31 26 25 21 20 16 15 11 10 6 5 0
valeur immédiate
15 0
Type R :
Type I :
rs
rt
rd
‣ Distinction simultanée des types d’instructions R et I en anticipation du décodage
‣ Le code UAL est dirigé vers le dispositif de contrôle de l’UAL noté C
94
© EFREI 2009 - Nicolas Sicard
1 0
rs
rt
rd
donnéeà écrire
[rt]
[rs]25-21
20-16
15-11
REG write
REG dest
Séquenceur
MIPS > Phase EXECUTE
Selon l’instruction, rt ou rd en destination : multiplexeur à l’entrée du banc de registres, commandé par le séquenceur (via le signal REG dest)
‣ Pour une instruction I, le signal REG write indique si une donnée doit être écrite ou non dans le registre destination (LOAD : REG write = 1, STORE : REG write = 0)
‣ Extension (X) de la valeur immédiate de 16 à 32 bits avant calcul (attention au signe)
rs codé sur 5 bitrt codé sur 5 bit
rd codé sur 5 bit
15-0valeur immédiatesur 16 bits X
32 bits
32 bits
32 bits
32 bits
95
© EFREI 2009 - Nicolas Sicard
UA
L
1 0
C
donnée àécrire
flagsUAL src
5-0
[rt]
[rs]32 bits
32 bits
32 bits
Phase EXECUTE > Gestion de l’UAL
Deux signaux déterminent le comportement de l’UAL :
‣ UAL op indique si une opération arithmétique ou logique a lieu (1) ou s’il s’agit d’une simple recopie de l’entrée vers la sortie (0)
‣ UAL src permet de choisir la seconde opérande entre [rt] (0) et la valeur immédiate étendue à 32 bits (1)
UAL op
valeurimmédiate
code UAL
UAL op = 0 UAL op = 1
UAL src =0
la valeur du registre rt est propagée en
sortie
opération (codeUAL) sur les valeurs des registres rs et rt
UAL src =1
la valeur immédiate
est propagée en sortie
opération (codeUAL) sur
les valeurs de rs et valeur imm.
32 bits
CCR
96
© EFREI 2009 - Nicolas Sicard
0 1
Mémoire (données)
MEM—>REG
MEMwriteMEM
read
donnée àécrire
donnée lue
Phase EXECUTE > Accès mémoire
sortie del’UAL
32 bits[rt]
Attention : seules les instructions LOAD et STORE impliquent la mémoire
Signaux de contrôle :
‣ MEM read / MEM write indiquent si la donnée doit être lue ou écrite
‣ MEM—>REG permet de choisir entre la sortie de la mémoire ou la sortie de l’UAL. Signal à 0 quand l’instruction n’est pas LOAD/STORE
adresse
Mread Mwrite M->R
LOAD 1 0 0
STORE 0 1 x
AUTRE 0 0 1
donnée
97
© EFREI 2009 - Nicolas Sicard
Mémoire (instructions)
1 0
+
+
PC
<<2
4
adresse
ET
branchementCCR<Z>
déplacement
32 bits
Phase EXECUTE > Instructions de branchement
Adresses mémoire des instructions multiples de 4
‣ passer d’une instruction à une autre : [PC] <— [PC] + 4
‣ Exemple : BEQ <deplacement> : [PC] <— [PC] + 4 + <deplacement> si Z=1 ( seulement +4 si Z=0 )
98
© EFREI 2009 - Nicolas Sicard
Mémoire (instructions)
UA
L
1
0
+
+
0
1
1
0
1 0
PC
X
D
4
donnée
adresse
31-26
25-21
20-16
15-11
15-0
ET
Contrôle
C
Mémoire (données)
branchement
MEM—>REG
MEMwriteMEM
read
donnée àécrire
donnée lueinstruction
ZUAL src
REG write
REG dest
5-0
rs
rt
rd[rt]
[rs]
UAL op
Processeur mono-cycle > Schéma synthétique
99
© EFREI 2009 - Nicolas Sicard
Pipeline (traitement entrelacé des instructions)
• Processeur mono-cycle n’est possible qu’avec des circuits très simples : la complexification des circuits conduit à une augmentation du temps de traversée du signal, à une diminution de la fréquence d’horloge donc des performances
• Idée : associer chaque phase (FETCH/EXEC/DECODE) à une unité fonctionnelle d’un cycle => micro-programmes. Conséquences : diminution du temps de cycle mais plus d’un cycle par instruction
• Meilleure idée : faire “travailler” les unités fonctionnelles en parallèle sur des instructions différentes ! On crée un pipeline d’instructions
100
© EFREI 2009 - Nicolas Sicard
Pipeline > Déroulement d’une instruction
instructioni
instructioni
instructioni
unitésfonctionnelles
FETCH
DECODE
EXECUTEcycles
d’horloge1 2 3
101
© EFREI 2009 - Nicolas Sicard
Pipeline > Déroulement de plusieurs instructions
i
i
i
unitésfonctionnelles
FETCH
DECODE
EXECUTE
cyclesd’horloge
1 2 3
i+1
i+1
i+1
i+2
i+2
i+2
4 5 6 7 8 9
102
© EFREI 2009 - Nicolas Sicard
Pipeline > Déroulement de plusieurs instructions
i
i
i
unitésfonctionnelles
FETCH
DECODE
EXECUTE
cyclesd’horloge
1 2 3
i+1
i+1
i+1
i+2
i+2
i+2
4 5 6 7 8 9
‣ Temps de traitement d’une instruction inchangé (3 cycles)
‣ Mais le débit global de traitement d’une séquence d’instructions a triplé (1 instr. par cycle au lieu d’une instr. tous les 3 cycles)
103
© EFREI 2009 - Nicolas Sicard
Pipeline > Exemple du MIPS
©Wikipedia 104
© EFREI 2009 - Nicolas Sicard
Problème des branchements :
‣ branchement pris : l’instruction suivante n’est pas i+1, il faut stopper le pipeline le temps de calculer la nouvelle adresse et de charger l’instruction
‣ dépendances de données entre instructions, ex : a = b+c puis d = 3*a;
‣ cas de l’exécution d’une boucle simple : un branchement à chaque itération
➡ systèmes de prédiction de branchement (statistiques) pour optimiser
Pipeline > Limitations
i
i
iFETCH
DECODE
EXECUTE
1 2 3
beq
beq
beq
i+D
i+D
i+D
4 5 6 7
105
© EFREI 2009 - Nicolas Sicard
Pipeline > Profondeur
La profondeur d’un pipeline est le nombre d’étages (ie. le nombre d’unités fonctionnelles).
Plus le nombre d’étages est grand, plus les circuits sont courts, plus la fréquence d’exécution est élevée.
Exemples :
‣ Intel Pentium 4E “Prescott” (architecture NetBurst 2004) : le pipeline pour le calcul d’entiers passe à 31 étages !
‣ par comparaison le Motorola PowerPC G4 présente 7 étages
Besoin d’unités de prédiction de branchement très efficaces : thèmes de recherche populaires au début des années 2000.
106
© EFREI 2009 - Nicolas Sicard
On duplique les unités fonctionnelles pour traiter deux instructions en parallèle
Architectures super-scalaires
i
i
i
unitésfonctionnelles
FETCH (1)
DECODE (1)
EXECUTE (1)
cyclesd’horloge
1 2 3
i+2
i+2
i+2
i+4
i+4
i+4
4 5 6 7 8 9
‣ Temps de traitement d’une instruction inchangé (3 cycles)
‣ Mais le débit global de traitement d’une séquence d’instructions a idéalement sextuplé (2 instr. par cycle au lieu d’une instr. tous les 3 cycles)
i+1 i+3 i+5
i+1 i+3 i+5
i+1 i+3 i+5
FETCH (2)
DECODE (2)
EXECUTE (2)
107
© EFREI 2009 - Nicolas Sicard
Autres architectures
VLIW :
‣ l’instruction (256 bits) contient les opérations pour chaque unité de calcul disponible
‣ nécessite d’importantes modifications des technologies de compilation
Architectures vectorielles :
‣ une seul instruction appliquée à plusieurs données simultanément
‣ s’applique uniquement à des problèmes adaptés (traitement image...)
‣ registres de grande taille (coûteux)
‣ mise en œuvre sous la forme d’unités particulières dans les processeurs génériques (Intel MMX/SSE - Motorola Altivec)
108
© EFREI 2009 - Nicolas Sicard
Tendances > Architectures multi-cœurs
Idée : prendre en compte le parallélisme “grossier” du fonctionnement d’un ordinateur (plusieurs processus en cours d’exécution)
‣ on duplique des CPU complètes sur un même circuit intégré
‣ partage de la mémoire (et mémoire cache) : problèmes de maintien de la cohérence des données entre unités de traitement
‣ nécessite une adaptation des systèmes d’exploitation et des programmes (multi-threading) : Grand Central (Apple), Threading Building Blocks (Intel)
Exemples :
‣ Intel Core 2 Duo : architecture dual-core (deux CPU)
‣ AMD dual Opteron (2005)
‣ IBM PowerPC 970MP
109
© EFREI 2009 - Nicolas Sicard
Tendances > Co-processeurs graphiques
GPGPU : General Purpose computing on Graphics Processing Units
‣ tirer parti de la puissance de calcul graphique et mémoire des cartes et chipsets vidéo actuels
‣ on déporte les calculs fortement SIMD vers la carte graphique
‣ on récupère le résultat dans la mémoire centrale
‣ nécessite une standardisation des langages et API d’accès aux GPU
Exemples :
‣ CUDA (Nvidia)
‣ OpenCL (Open Computer Library)
110
© EFREI 2009 - Nicolas Sicard
UAL > Récapitulatif
L’unité de commande (séquenceur) orchestre les échanges entre la mémoire, l’unité de calcul (UAL) et les registres à chaque cycle d’horloge, en fonction des instructions du programme
Les instructions sont des mots mémoire contenant un code opération (op-code) et des opérandes (valeurs, adresses mémoire ou de registre)
Les branchements conditionnels sont assurés par des instructions spécifiques qui modifient le registre PC en fonction de l’état du registre de condition (CCR)
L’utilisation du pipeline d’instructions permet d’optimiser l’utilisation des unités de calcul et de mouvements mémoire et d’augmenter le débit de traitement
111
© EFREI 2009 - Nicolas Sicard
La hiérarchie mémoire
112
© EFREI 2009 - Nicolas Sicard
La hiérarchie mémoire
Organisation
Adressage
Mémoire cache
113
© EFREI 2009 - Nicolas Sicard
46 0
23 1
87 2
94 3
... ...
17 2N-1
La mémoire > Organisation
Mémoire de 2N mots de M bits :
R
WBus
d’adresses
Busde
données
adresses
M bits ‣ N : largeur du bus d’adresse
‣ M : largeur du bus de données
‣ 8 : coefficient bits/octet
Capacité C de la mémoire en octets :
C =2NM
8
114
© EFREI 2009 - Nicolas Sicard
46 0
23 1
87 2
94 3
... ...
17 2N-1
La mémoire > Organisation
Mémoire de 2N mots de M bits :
R
WBus
d’adresses
Busde
données
adresses
M bits Pour C = 256 Mo :
Quelle est la meilleure réparition ?
M N C (octets)
8 bits 28 bits (228 x 8) / 8
32 bits 26 bits (226 x 32) / 8
64 bits 25 bits (225 x 64) / 8
115
© EFREI 2009 - Nicolas Sicard
La mémoire > Critères d’organisation
• nombre de pistes : nombre minimal pour N maximal
• différences entre les tailles des données traitées par la CPU et les applications (8, 16, 32 ou 64 bits ?)
• privilégier les performances de débit (quantité de données chargées en un échange) :
‣ augmenter la taille de la cellule mémoire
‣ augmenter la largeur du bus de données
‣ réduire la largeur du bus d’adresses
116
© EFREI 2009 - Nicolas Sicard
Organisation > Traitement des octets
Augmenter les performances de débit implique une augmentation de la largeur du bus de données (32 ou 64 bits). Par ailleurs, l’unité naturelle de traitement des processeurs tend vers 32 ou 64 bits.
Mais historiquement beaucoup de données sont encore codées sur des mots de 8 bits (typage du langage C, fichiers texte...) : l’incrément d’adresse est le plus souvent de 1 octet.
Problème : comment traiter un mot (32 bits) ou un demi-mot (16 bits) pour l’adressage et le stockage “calé” sur 8 bits ?
2 écoles : petit boutisme (little endian) et grand boutisme (big endian)
117
© EFREI 2009 - Nicolas Sicard
Traitement des octets > Endianness
Ordre de rangement des octets à l’intérieur d’un mot de 32 bits en mémoire d’incrément d’adresse d’un octet
Gros boutisme (big endian) :
Petit boutisme (little endian) :
@
#
α
0 1 2 3
55 4E 49 58
U N I X
32 bits
32 bits
@
#
α
0 1 2 3
58 49 4E 55
X I N U
Ex : 0x554E4958
118
© EFREI 2009 - Nicolas Sicard
Traitement des octets > Endianness
Ordre de rangement d’un octet à l’intérieur d’un mot de 32 bits en mémoire d’incrément d’adresse d’un octet
Gros boutisme (big endian) :
Petit boutisme (little endian) :
@
#
0 1 2 3
.00 .00 .00 .01
32 bits
32 bits
@
#
0 1 2 3
.01 .00 .00 .00
Ex : 0x01
119
© EFREI 2009 - Nicolas Sicard
Traitement des octets > Big Endian
Ordre de rangement des octets à l’intérieur d’un mot de 32 bits dans l’ordre mots de “poids fort en tête”
Gros boutisme (big endian) :
Exemples : Motorola 68000, SPARC (Sun Microsystem)
Avantage : dans l’ordre naturel de lecture d’un nombre
@
#
0 1 2 3
.00 .00 .00 .01
32 bitsEx : 0x01
120
© EFREI 2009 - Nicolas Sicard
Traitement des octets > Little Endian
Ordre de rangement des octets à l’intérieur d’un mot de 32 bits dans l’ordre mots de “poids faible en tête”
Petit boutisme (little endian) :
Exemples : Famille Intel x86
Avantage : accès direct aux petites valeurs en 8 ou 16 bits (il suffit de tronquer après le 1er ou le 2nd octet).
32 bits
@
#
0 1 2 3
.01 .00 .00 .00
Ex : 0x01
121
© EFREI 2009 - Nicolas Sicard
int main(){ unsigned int i=0; unsigned char *pval8; unsigned char str[]="UNIX"; unsigned long val32; unsigned short val16;
val32 = 0x554E4958; val16 = 0xABCD;
printf("Stockage d'une val 16 bits\n"); printf("val16 = %#X @%#x\n", val16, &val16); pval8 = (unsigned char*)(&val16); for(i = 0; i < 4; i++)
printf("val8[%d] = %#02X\n",i, pval8[i]);
printf("Stockage d'une val 32 bits\n"); printf("val32 = %#X @%#x\n", val32, &val32); pval8 = (unsigned char*)(&val32); for(i = 0; i < 4; i++)
printf("val8[%d] = %#02X\n",i, pval8[i]); for(i = 0; i < 4; i++)
printf("%c",pval8[i]);
printf("Stockage d'une char*\n"); printf("val8 = %s @%#x\n", str, str); pval8 = str; for(i = 0; i < 4; i++)
printf("%c",pval8[i]);
return 0;}
Stockage d'une val 16 bitsval16 = 0xABCD @0xbffffa7aval8[0] = 0xCDval8[1] = 0xABval8[2] = 0x58val8[3] = 0x49 Stockage d'une val 32 bitsval32 = 0x554E4958 @0xbffffa7cval8[0] = 0x58val8[1] = 0x49val8[2] = 0x4Eval8[3] = 0x55 XINUStockage d'une char*val8 = UNIX @0xbffffa83UNIX
@0xbffffa7a
@0xbffffa7b
@0xbffffa7c
@0xbffffa7d
@0xbffffa7e
@0xbffffa7f
@0xbffffa80
@0xbffffa81
@0xbffffa82
@0xbffffa83
@0xbffffa84
@0xbffffa85
@0xbffffa86
@0xbffffa87
val160xCD
val160xAB
val32
0x58 (‘X’)
val320x49 (‘I’)
val320x4E (‘N’)
val32
0x55 (‘U’)
Non utilisé(Alignement)Non utilisé(Alignement)Non utilisé(Alignement)Non utilisé(Alignement)Non utilisé(Alignement)Non utilisé(Alignement)
str
‘U’
str
‘N’
str ‘I’str
‘X’
str
‘\0’
Mém
oire
Sor
tie s
tand
ard
Pro
gram
me
Endianness > Exemple (Little Endian)
122
© EFREI 2009 - Nicolas Sicard
Traitement des octets > Bilan
Problème : stockage cohérent dans une même machine mais pas entre architectures différentes (sauf si les données sont codées comme une suite d’octets (ex: ASCII) ).
Transmission des mots mémoire (>8 bits) : nécessité de connaître l’ordre de chaque machine connectée ?!
Protocole IP (Internet) : impose le standard Network byte order (= big endian) pour tous les paquets transmis, quel que soit l’endianness naturel de la machine.
Remarque : beaucoup d’architectures acceptent les deux modes (PowerPC, ARM, MIPS, IA-64...)
123
© EFREI 2009 - Nicolas Sicard
Organisation > Hiérarchie mémoire
coût àl’octet
temps deréponse
taille
volatile
persistante
~100 octets
1 à 8 Go
4 à 50 Go
100 Go à 1To
1 To à 10 To
~ 100 To
registres
RAM
disques durs
disques optiques
bandes magnétiques (DAT, DLT...)
systèmes d’archivage (robots...)
124
© EFREI 2009 - Nicolas Sicard
Organisation > Mémoires RAM
RAM : Random Access Memory (accès non séquentiel)
SRAM : Static RAM (à base de bascules, pas de rafraichissement nécessaire, alimentation électrique continue, coûteux)
DRAM : Dynamic RAM (à base de transistors, rafraichissements réguliers, haute densité, bon marché)
FPM RAM : Fast Page Mode RAM (lecture par blocs)
EDO RAM : Extended Data Out RAM (moins de rafraîchissements)
SDRAM : Synchronous DRAM (synchronisé au bus de la CPU, accès entrelacés)
DDR(1,2,3) SDRAM : Dual Data Rate SDRAM (débit double)
125
© EFREI 2009 - Nicolas Sicard
Organisation > RAM vs. CPU
Remarque : un processeur à 2Ghz est capable de traiter plus d’une donnée toutes les 0,5ns, une RAM rapide a une latence de l’ordre de 5 à 10ns...
Question : comment accélérer les transferts ?
‣utiliser au maximum les registres (mais taille limitée et problème de compilation)
‣augmenter le débit (une des améliorations de l’architecture)
‣réduire la distance entre la RAM et la CPU ?....
126
© EFREI 2009 - Nicolas Sicard
RAM vs. CPU > Distance
Question : quelle distance L est parcourue par un signal en 0,5ns ?
‣au plus rapide (vitesse de la lumière) c = 3.108 ms-1
‣T = 0,5ns = 5.10-10s
‣L = c.T = 0,15m !
Idéal : intégration de la mémoire au support du processeur
Problème : intégration trop coûteuse, peu flexible (augmentation de la mémoire)
Solution : mémoire intermédiaire en taille et en rapidité entre la mémoire centrale et la CPU.
127
© EFREI 2009 - Nicolas Sicard
Organisation > Mémoire cache
Mémoire de taille réduite (de 32Ko à 4Mo selon la proximité) qui contient une copie de fragments de la mémoire centrale
Le temps d’accès au cache tc est très inférieur au temps d’accès de la mémoire tm. RAM
CACHE
CPU
tc
tm >> tc
128
© EFREI 2009 - Nicolas Sicard
Mémoire cache > Principe
Le cache donne l’illusion d’une mémoire très rapide de grande capacité. Pour obtenir une donnée, la CPU va transmettre son adresse au cache.
‣si le cache possède la donnée correspondante, il la transmet au CPU (rapide)
SUCCES = CACHE HIT
‣sinon, la donnée est en mémoire, il faut la faire transiter depuis la RAM (lent)
ECHEC = CACHE MISS
129
© EFREI 2009 - Nicolas Sicard
Mémoire cache > Performances
Soit tglob le temps moyen d’accès à une donnée, tc le temps d’accès via le cache et tm le temps d’accès via la mémoire. Soit h (0 ≤ h ≤ 1) le taux de HIT.
On fait un accès au cache (tc) à chaque requête mémoire :
‣s’il y a HIT, alors on n’accède pas à la mémoire
‣sinon, on doit accéder à la mémoire en un temps tm avec un taux de 1-h
d’où un temps d’accès moyen :
tglob = tc + (1-h)tm
130
© EFREI 2009 - Nicolas Sicard
Performances > Application numérique
Soit Cc=1Go la capacité du cache et Cm=1Mo la capacité de la RAM. Soit tc = 8ns et tm = 40ns.
Hypothèse : le cache contient des données sélectionnées aléatoirement, donc h = Cc/Cm = 1/1024 = 2-10 << 1.
Alors :tglob = tc + (1-h)tm ≈ tc + tm = 48ns > tm !!
Conclusion : on doit optimiser le choix des données stockées en cache pour maximiser le nombre de HIT. Il faut anticiper les accès.
Questions : Comment optimiser le contenu de la mémoire cache pour augmenter le taux de succès ? Quelles données copier en cache ? Comment faire quand le cache est plein ?
131
© EFREI 2009 - Nicolas Sicard
Performances > Principe de localité temporelle
Lorsqu’un programme accède à une certaine adresse, il est probable qu’il y accède de nouveau peu de temps après.
Exemples : les programmes sont souvent construits à base de boucles, d’où une réutilisation fréquente de certaines valeurs (compteurs...)
Conséquence : lors de la mise à jour d’une valeur dans le cache (à cause d’un miss), on a intérêt à éliminer les données les plus anciennes d’abord.
Méthode FIFO (First In First Out) empile les accès
Méthode LRU (Least Recently Used) compte le nombre d’accès depuis la dernière lecture/écriture pour chaque emplacement
132
© EFREI 2009 - Nicolas Sicard
Performances > Principe de localité spaciale
Quand un programme accède à une donnée à une certaine adresse, il est probable qu’il accède à des données aux adresses proches de celle-ci.
Exemples : un programme lui-même est une séquence d’instructions contigües en mémoire, programmes de manipulation de texte (séquence de caractères), d’images, de son...
Conséquence : lors de la mise à jour d’une valeur dans le cache (à cause d’un miss), on a intérêt à transférer un bloc de valeurs localement proches en mémoire. On parle alors de lignes de cache.
133
© EFREI 2009 - Nicolas Sicard
Evolution du cache > Cas d’une lecture
Au départ, on considère que la mémoire cache est vide.
Si la CPU veut accéder à une donnée, elle présente son adresse à la mémoire cache. Deux cas possibles :
‣ la donnée n’est pas disponible en cache (MISS) :
1. la ligne de cache correspondante est cherchée en RAM
2. elle est recopiée dans le cache, éventuellement en remplacement d’une autre ligne de cache (LRU)
‣ la donnée est présente en cache (HIT) : elle est transmise à la CPU. Le cache n’est pas mise à jour mais la date d’accès à la ligne de cache est rafraîchie
134
© EFREI 2009 - Nicolas Sicard
Evolution du cache > Cas d’une écriture
La CPU veut enregistrer une donnée, il fournit sa valeur et son adresse. Ecriture en cache ? Ou en RAM ? En cache et en RAM ?
Important : préserver la cohérence des données entre RAM et cache. La RAM est la référence : la donnée est écrite en RAM.
Comportement du cache :
‣ écriture de la valeur surtout si la données y est déjà présente
‣ le plus simple est d’invalider la donnée en cache si elle s’y trouve (pas de mise à jour nécessaire, il suffit d’activer un bit d’invalidation)
135
© EFREI 2009 - Nicolas Sicard
Mémoire cache > Implémentation
Question : quelles implémentations pour ce type de mémoire dans un circuit ?
Il en existe deux grandes familles :
‣ les caches associatifs : chaque emplacement du cache contient un couple (adresse / valeur)
‣ les caches à correspondance directe : à un emplacement donné du cache ne correspond qu’un ensemble restreint d’adresses
Les solutions retenues et implémentées réellement sont bien souvent un compromis entre les deux !
136
© EFREI 2009 - Nicolas Sicard
Implémentation > Cache Associatif
Comparable à un tableau indexé :
v adresse donnée(s)
v adresse donnée(s)
v adresse donnée(s)
.........
v adresse donnée(s)
v adresse donnée(s)
Cache de 2N emplacements
1 emplacementde cache
bits d’invalidation lignes de cache
137
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Lecture
0 @0x00 ????????
0 @0x00 ????????
0 @0x00 ????????
.........
0 @0x00 ????????
0 @0x00 ????????
CPU bus d’@
lecture @0x10
MISS
On cherche l’adresse 0x10 dans le cache, ligne par ligne.
Si elle n’est pas présente dans le cache, il y a échec (MISS)...
cache initialement vide
138
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Màj. après MISS
1 @0x10
0 @0x00 ????
0 @0x00 ????
.........
0 @0x00 ????
0 @0x00 ????
CPU bus d’@
lecture @0x10
RAMbus de données 0xABCD0xABCD
... la donnée est alors transmise depuis la RAM vers le cache et la CPU
cache initialement vide
139
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Lecture (II)
1 @0x10 0xABCD
0 @0x00 ????
0 @0x00 ????
.........
0 @0x00 ????
0 @0x00 ????
CPU bus d’@
lecture @0x10
RAMbus de données
Si la donnée est présente et valide, elle est rapatriée directement depuis le cache.
HIT
0xABCD
140
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Lecture (III)
1 @0x10 0xABCD
1 @0x86 0x875D
0 @0x00 ????
.........
@0x4A
1 @0x25 0x0000
CPU bus d’@
lecture @0x4A
RAMbus de données
Si la donnée est présente mais invalide, elle est transmise depuis la RAM vers le cache et la CPU
0x43210x4321
0xE65F01
MISS
141
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Lecture (MISS + cache plein)
1 @0x10 0xABCD 0
1 @0x86 0x875D 3
1 @0x12 0x6234 2
.........
1 @0x4A 0xE65F 8
1 @0x25 0x0000 5
CPU bus d’@
lecture @0x31
Si la donnée n’est pas présente et que le cache est plein...
âge de l’emplacement
MISS
142
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Lecture (LRU)
1 @0x10 0xABCD 1
1 @0x86 0x875D 4
1 @0x12 0x6234 3
.........
1 @0x31 0
1 @0x25 0x0000 6
CPU bus d’@
lecture @0x31
RAMbus de données 0x43210x4321
“âge” de l’emplacement
Si la donnée n’est pas présente et que le cache est plein...
... il faut remplacer la ligne la plus “âgée” par les nouvelles données provenant de la RAM.
143
© EFREI 2009 - Nicolas Sicard
Cache Associatif > Ecriture
Deux politiques principales :
‣write-through : chaque écriture dans le cache est immédiatement répercutée dans la RAM
‣write-back : une ligne de cache n’est écrite en mémoire que lorsqu’elle est libérée. Dans ce cas, un bit particulier (dirty bit) indique si les données ont été modifiées ou non en cache. Si oui, l’écriture est effectuée, sinon la ligne est simplement libérée
Politiques intermédiaires :
‣write-through : écritures stockées dans une file d’attente
‣write-back : écritures pendant les périodes sans échange avec la mémoire
144
© EFREI 2009 - Nicolas Sicard
Implémentation > Cache à correspondance directe
Défauts des caches associatifs :
‣ stockage de l’adresse entière (pour chaque ligne de cache)
‣ les adresses ne sont pas classées : la recherche dans le tableau associatif est très complexe en circuits donc longue et coûteuse
Solution : ne faire correspondre qu’un seul emplacement du cache à une adresse mémoire donnée.
Inversement, à un emplacement donné peuvent correspondre plusieurs adresses.
Technique : une partie de l’adresse (codée sur p bits) code le numéro de l’emplacement correspondant
145
© EFREI 2009 - Nicolas Sicard
Cache à correspondance directe > Adresse
tag index offset
adresse mémoire (p bits)
indice du mot mémoiredans la ligne de cachecontenant 2r mots
r bitsq bits
indice de la ligne dans lecache contenant 2q lignes
p-q-r bits
“étiquette” de la lignede cache stockée
à l’indice index
Toutes les adresses de même index se partagent la même ligne de cache
146
© EFREI 2009 - Nicolas Sicard
Cache à correspondance directe > Exemple
Cache de 28 (256) emplacements
de 16 octets
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0
0xB3
......................................................
0xFD
0xFE
0xFF
adresse mémoire (32 bits)tag index (8 bits) offset (4 bits)
980A0 B2 A
147
© EFREI 2009 - Nicolas Sicard
Cache à correspondance directe > Lecture
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0
0xB3
......................................................
adresse mémoire (32 bits)tag index (8 bits) offset (4 bits)
980A0 B2 A
=
HIT/MISS
MUX
bus de données 148
© EFREI 2009 - Nicolas Sicard
Cache à correspondance directe > Bilan
Avantages :
‣ stockage d’une partie de l’adresse seulement (tag)
‣ accès direct à l’emplacement de la ligne de cache
Inconvénients :
‣ un seul emplacement possible pour une adresse => conflits
‣ effets “ping-pong” lors d’accès mémoire alternés à partir d’adresses de même index (màj. du cache à chaque accès)
Objectifs : profiter des avantages des deux types de cache...
149
© EFREI 2009 - Nicolas Sicard
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0
0xB3
......................................................
0xFD
0xFE
0xFF
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0
0xB3
......................................................
0xFD
0xFE
0xFF
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0
0xB3
......................................................
0xFD
0xFE
0xFF
index tag data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)data (16 octets)
0 1 2 3 4 5 6 7 8 9 A B C D E F
0x01
0x02
0x03
......................................................
0xB1
0xB2 980A0 ?
0xB3
......................................................
0xFD
0xFE
0xFF
Caches associatifs par 2/4/8 > Exemple
4 x caches de 256 emplacements de
16 octets
adresse mémoire (32 bits)tag index (8 bits) offset (4 bits)
980A0 B2 A
2, 4 ou 8 emplacements possibles pour chaque index
150
© EFREI 2009 - Nicolas Sicard
Niveaux de caches
Objectifs : trouver le meilleur compromis possible coût/performances.
Contraintes : plus une mémoire est rapide, plus elle est chère
Techniques : ajouter des niveaux de cache
‣ L1 (interne) : intégré à la CPU, petite capacité (32/64Ko), très rapide, séparation des instructions et des données
‣ L2 (externe) : capacité moyenne (512Ko/2Mo), éloigné de la puce
151
Recommended