Microprocesseurs

Transcription

Microprocesseurs

Chapitre 2
Microprocesseurs
2.1 Introduction
Le microprocesseur est à l’ordinateur ce que le cerveau est à l’être humain. C’est à dire un mécanisme
régulateur chargé de réaliser la coopération entre les différents éléments (RAM, ROM, PIO) qui lui sont
associés dans le but de réaliser des opérations. Un microprocesseur est donc avant tout un calculateur. Il
est intéressant de noter que la discipline qui traite de l’étude des ordinateurs est définie par deux termes
différents en fonction des cultures mais qui expriment deux aspects complémentaires des machines : ce
qu’elles font et ce à quoi elles peuvent servir.
– certains utilisent le terme computer science ou science des calculateurs et expriment ainsi qu’un
ordinateur est une machine axée sur le calcul,
– d’autres parlent d’informatique contraction des mots information et automatique pour exprimer
qu’un ordinateur est aussi utilisé comme outil de traitement automatique de l’information.
On comprendra aisément que la différence entre calcul et traitement de l’information est tenue dès lors
que l’on sait qu’un ordinateur n’a pas conscience de la différence entre un chiffre et une lettre puisque pour
lui toute information se résume à des interrupteurs allumés ou éteints.
2.1.1 Architecture de Von Neumann
Les premiers calculateurs virent le jour durant la seconde guerre mondiale. Cependant jusqu’en 1945
leur utilisation se révélait plutôt fastidieuse en raison de leur architecture. Par exemple, l’ENIAC (Electronic Numerical Integrator And Calculator) conçu en 1945 par John Eckert et John Mauchly à l’université
de Pennsylvanie était composé de 18000 tubes à vide et 6000 commutateurs interconnectés par un enchevêtrement de câbles, le tout pesant 30 tonnes. Il était capable de multiplier deux nombres de 10 chiffres
décimaux en 3 ms. Les programmes de l’ENIAC étaient écrits sur des cartes perforées et il fallait brancher
et débrancher des dizaines de câbles pour lancer un calcul.
John Von Neuman mathématicien d’origine hongroise avait participé à la construction de l’ENIAC.
Il travailla ensuite à Princeton à la construction d’une nouvelle machine : l’EDVAC (Electronic Discrete
Variable Automatic Computer) qui préfigure l’architecture des ordinateurs modernes.
Mémoire
Entrée
Unité de
Commande
UAL
ACC
Sortie
F IG . 2.1 – Architecture de Von Neumann
La machine de Von Neumann était formée de 5 composantes (cf. figure 2.1) : mémoire, unité arithmétique
23
22 octobre 2005
Couche physique et logique, représentation ...
et logique, unité de contrôle, dispositifs d’entrées et sorties. Von Neumann montra que pour être efficace
son architecture devait fonctionner électroniquement selon la numérotation binaire.
Paradoxalement, en raison de querelles intestines entre les concepteurs de l’ENIAC concernant la paternité de certains brevet la conception de l’EDVAC pris du retard et c’est le britannique Maurice Wilkes qui
à Cambridge en 1949 acheva la conception du premier ordinateur basé sur l’architecture de Von Neumann :
l’EDSAC (Electronic Delay Storage Automatic Calculator). Aujourd’hui tous nos ordinateurs fonctionnent
suivant le modèle de Von Neumann.
2.2 Organisation fonctionnelle
Un microprocesseur ou CPU pour Central Processing Unit (ou unité centrale de traitement UCT)
se compose de deux unités fonctionnelles : l’UAL qualifée de partie opérative et l’UC qualifiée de partie
contrôle.
– l’UAL ou Unité Arithmétique et Logique compose la partie opérative du microprocesseur, c’est à
dire qu’elle effectue les calculs et les transferts de données nécessaires à la réalisation des opérations
arithmétiques,
– l’UC ou Unité de Contrôle se charge de décoder les commandes et de les exécuter en envoyant à
l’UAL les calculs à effectuer.
2.2.1 Registres
Le CPU se compose également de registres qui sont des mots mémoires propres au processeur et qui
mémorisent l’état dans lequel se trouve le processeur. Les registres de base sont les suivants :
• le Compteur Ordinal CO contient l’adresse en mémoire de la prochaine instruction à exécuter. Il est
mis à jour après chaque exéction d’une instruction
• le registre d’instruction RI contient l’instruction à exécuter. Il se compose de deux parties :
– une zone opération qui représente le code de l’opération
– une zone qui contient une donnée ou une adresse
• l’accumulateur ACC est un registre important de l’UAL puisque c’est avec lui que sont réalisées la
plupart des opérations arithmétiques.
• le registre d’état PSW (Program Status Word) est un indicateur du résultat d’une opération réalisée
par l’UAL. Il indique entre autres choses si le résultat est égal à zéro ou un dépassement de capacité.
• le pointeur de pile SP (Stack Pointer) indique le sommet de la pile des appels de procédures.
• les registres généraux qui sont des registres utilisés dans certaines instructions particulières.
2.2.2 L’unité arithmétique et Logique
Accumulateur
Registre d’état
C Z V S P
U.A.L
A
B
Commande
Mémoire
F IG . 2.2 – Schḿa d’une UAL
L’UAL se compose de registres et de circuits arithmétiques (additionneur, soustracteur, comparateur,
décaleur) permettant de réaliser des opérations entre registres.
24
22 octobre 2005
On peut par exemple imaginer une UAL de base composée de 2 registres A et B et réalisant 8 opérations
différentes entre A et B :
ADD
SUB
MUL
DIV
AND
OR
XOR
CMP
A+B →A
A−B →A
A×B →A
A/B → A
A and B → A
A or B, → A
A xor B → A
A =, >, < B → f lags
addition
soustraction
multiplication
division
et logique
ou logique
ou exclusif
comparaison
En sortie de l’UAL se trouve le registre d’état comprenant des flags (indicateurs) qui informent l’utilisateur quant au résultat de l’opération effectuée :
Flags
C
Z
V
S
P
Rôle
indicateur de retenue
indicateur de valeur nulle
indicateur de débordement
indicateur de signe
indicateur de parité
Ainsi, si l’on compare le contenu des registres A et B, on pourrait choisir la convention d’état des flags
suivante pour indiquer le résultat de la comparaison :
Z
1
0
1
0
1
Condition
A=B
A>B
A≥B
A<B
A≤B
C
0
1
1
0
0
S
0
0
0
1
1
2.2.3 L’unité de contrôle
Elle coordonne l’exécution des commandes et se compose de deux circuits :
– le décodeur qui à partir de la commande contenue dans le registre d’instruction détermine quelle
commande devra être exécutée,
– le séquenceur réalise l’exécution de la commande en envoyant des microcommandes à d’autres circuits du système dans un ordre précis
2.2.4 Description d’un langage machine
L’ordinateur ne comprend qu’une série d’instructions codées de manière bien définie et que l’on nomme
langage machine. Un programme en langage machine est décrit par une série de nombres exprimés généralement
en hexadécimal. Pour faciliter l’utilisation du langage machine on a conçu un langage d’usage plus intuitif
pour l’être humain et baptisé langage d’assemblage ou plus brièvement assembleur.
Nous allons procéder de manière inverse en décrivant un langage d’assemblage et en montrant comment
on peut le coder au niveau de la machine (cf. TD 6).
Maurice Wilkes de l’université de Cambridge mit au point le premier langage assembleur en 1950.
2.2.4.1 Langage assembleur
Supposons que nous disposions d’une machine très simple composée
– d’un bus d’adresse de 16 bits,
– d’un bus de données de 8 bits,
– d’une mémoire de 64 Ko,
25
22 octobre 2005
Compteur
Ordinal
11 0
00
1
00 1
11
00
1
0
1
LCO
Accumulateur
CRA
Bus d’adresses
01
10
Centrale
Séquenceur
Décodeur
U.A.L
0110
CEB
EDA
Mémoire
PSR
R.E
0110
CCO
1
0
0
1
CAD
LEC
1
0
0
1
1
0
0
1
ECR
Registre
R.I.
0110
Code
Opération
CEA
Bus de données
Adresse
1
0
0
1
LMM
1
0
0
1
1
0
0
1
EMM
CRI
F IG . 2.3 – Schéma d’une Unité Centrale de Traitement
– d’une UAL de deux registres A, B et d’un registre de pile SP
Le langage que nous utiliserons se compose de quatre séries d’instructions :
• des instructions d’accès à la mémoire et aux registres
0 MOV A,B
mettre la valeur de B dans A
MOV B,A
mettre la valeur de A dans B
1 MOV A,data
mettre la valeur data dans A
MOV B,data
mettre la valeur data dans B
2 MOV A,[adr]
mettre le contenu de l’adresse [adr] dans A
MOV B,[adr]
mettre le contenu de l’adresse [adr] dans B
3 MOV [adr],A
mettre le contenu de A à l’adresse [adr]
MOV [adr],B
mettre le contenu de B à l’adresse [adr]
4 MOV A,[SP+dec] mettre la valeur de pile dans A
MOV B,[SP+dec] mettre la valeur de pile dans B
5 MOV [SP+dec],A mettre la valeur de A dans la pile
MOV [SP+dec],B mettre la valeur de B dans la pile
• des instructions arithmétiques et logiques ADD, SUB, DIV, MUL, AND, OR, XOR, CMP qui peuvent
avoir trois déclinaisons
ADD A,data
additionner la valeur data à A
ADD A,[adr] additionner le contenu de l’adresse [adr] à A
ADD A,B
additionner B à A
• des instructions de déplacement conditionnelles et d’appel de coroutines :
26
22 octobre 2005
JE
adr saut à l’adresse adr si A = B
JNE adr saut à l’adresse adr si A 6= B
JG
adr saut à l’adresse adr si A > B
JGE adr saut à l’adresse adr si A ≥ B
JL
adr saut à l’adresse adr si A < B
JLE adr saut à l’adresse adr si A ≤ B
CALL adr saut à l’adresse adr
RET
retour d’appel
Pour les 6 premières instructions un appel préalable à l’instruction CMP doit être effectué. Pour l’instruction CALL, l’adresse de la prochaine instruction à exécuter est placée sur la pile. L’instruction
RET permet de revenir à cette instruction.
• des instructions de manipulation de la pile
PUSH A empiler le contenu de A
PUSH B empiler le contenu de B
POP A dépiler et mettre le sommet de pile dans A
POP B dépiler et mettre le sommet de pile dans B
2.2.4.2 Influence de la longeur des adresses
Lors de la conception d’un microprocesseur, le codage des instructions revêt un aspect important. Il
s’agit pour le concepteur de définir un format d’instruction qui permette de coder l’instruction à réaliser
mais également les données ou adresses sur lesquelles on doit travailler.
En effet, plus les instructions sont courtes plus elles sont efficaces : si une machine possède une mémoire
ayant un débit de d bits/s et que la longueur moyenne de ses instructions est de n bits, alors cette mémoire
peut délivrer d/n instructions par seconde.
Il faut également prendre en compte la largeur en bits d’une instruction et s’arranger pour que les
instructions aient une taille multiple de la largeur des données manipulées par le processeur afin d’éviter le
gaspillage de la mémoire.
La largeur des adresses influe également sur les performances. Considérons par exemple une mémoire
de 64 Ko. Celle-ci peut être organisée sous deux formats différents :
– cas n◦ 1 : une mémoire de 216 octets
– cas n◦ 2 : une mémoire de 214 mots de 4 octets
Si on désire comparer 1 octet avec un autre octet, dans le cas 2 cela entraı̂ne un surcoût car il faut
charger 2 fois 4 octets depuis la mémoire et extraire les octets correspondants. Cependant, plus une adresse
est courte, plus l’instruction correspondante est courte. Il y a donc un compromis à trouver.
2.2.4.3 Code opération expansif
Considérons une machine codant des instructions sur m = c + a bits, soit c bits pour le code opération
et a bits pour l’adresse. Cette codification permet de représenter 2c instructions et 2a adresses. On peut
désirer modifier ce codage des instructions de la manière suivante :
– c + 1 bits pour le code opération et a − 1 bits pour l’adresse, soit 2 fois plus d’instructions mais 2 fois
moins d’adresses
– ou c − 1 bits pour le code opération et a + 1 bits pour l’adresse, soit 2 fois moins d’instructions mais
2 fois plus d’adresses
Le procédé qui consiste à modifier le nombre de bits réservés au codage des instructions en fonction de
leur nombre et de l’adressage mémoire s’appelle code opération expansif. Exemple :
00
01
10
1100
1101
1110
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx
xxxxxxxxxxxxxx
3 instructions avec adresse sur 14 bits
xxxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxx
27
22 octobre 2005
11110000
..
.
xxxxxxxx
..
.
11111111
xxxxxxxx
2.3 Exemple de langage Assembleur : l’Intel 8086/Pentium
Le Pentium est capable d’exécuter un programme dans différents modes de fonctionnement :
• le mode protégé multitâche permet d’utiliser toute la puissance du processeur. Les registres sont des
registres 32 bits.
• le mode virtuel permet à des applications 8086 (environnement DOS) de s’exécuter dans le mode
protégé,
• le mode réel correspond au fonctionnement d’un 8086. Les registres 32 bits (EAX, ...) ne sont pas
disponibles, on utilise des registres est de 16 bits (AX, ...).
2.3.1 Registres
Il existe 8 registres généraux de 32 bits EAX, EBX, ECX, EDX, EDI, ESI, EBP, ESP dont la partie basse
(16 premiers bits) peut être manipulée séparément de la partie haute, on utilise alors les dénominations AX,
BX, CX, DX, DI, SI, BP, SP.
Parmi ces registres on distingue :
– les registres de données : EAX, EBX, ECX, EDX dont la partie basse se subdivisent en 2 sous
registres de 8 bits l’un appelé partie haute (H) et l’autre appelé partie basse (L). Par exemple : AX de
d{ecompose en AL, AH.
– EAX (accumulateur) : utilisé pour les multiplications et divisions, c’est le plus rapide pour la
réalisation d’opérations arithmétiques et logiques,
– EBX utilisé comme opérande ou comme registre pointeur (cf. ci-après),
– ECX (compteur) utilisé comme compteur dans les opérations itératives comme le transfert de
données
– EDX utilisé pour les multiplications et divisions ainsi que l’accès aux circuits d’entrées et sorties.
– les registres pointeurs et index :
– EIP (Instruction Pointer) : pointeur d’instruction, non modifiable par le programmeur,
– ESP (Stack Pointer) : pointeur de pile
– EBP (Base Pointer) : utilisé par le programmeur pour pointer sur un emplcameent de la pile
– ESI (Source Index)
– EDI (Destination Index)
– les registre segments qui combinés aux registres pointeurs et index permettent d’adresser les données.
– CS (Code Segment) : segment courant du code (CS:IP contient l’adresse de la prochaine instruction à exécuter),
– DS (Data Segment) : segment courant des données,
– SS (Stack Segment) : segment courant de la pile,
– ES (Extra Segment) : segment additionnel,
– FS (Extra Segment) : segment additionnel,
– GS (Extra Segment) : segment additionnel.
Les registres segments sont composés d’une partie visible de 16 bits et d’une partie cachée comprenant des informations relatives à la taille du segment, son type et ses droits d’accès.
– un registre d’état EFLAGS de 32 bits comprenant des indicateurs (status flags) chacun codé sur un
bit :
– AF (Auxiliary Flag) : indicateur de retenue auxiliaire, mis à 1 lorsqu’il y a une retenue du quartet
de poids faible dans le quartet de poids fort,
– CF (Carry Flag) : indicateur de retenue, mis à 1 lorsqu’un calcul produit une retenue sur 8 ou 16
bits,
– OF (Overflow Flag) : indicateur de débordement indiquant que l’on a dépassé les possibilités de
stockage et qu’un bit significatif a été perdu,
– SF (Sign Flag) : indicateur de signe, utilisé pour les opérations sur les nombres signés,
28
22 octobre 2005
– PF (Parity Flag) : indicateur de parité, mis à 1 si le résultat d’une opération contient un nombre
pair de 1,
– ZF (Zéro Flag) : indicateur de 0, mis à 1 quand le résultat d’une opération est 0.
2.3.2 Adressage mémoire
Le calcul d’une adresse mémoire physique dépend du mode de fonctionnement du processeur.
– en mode protégé une adresse s’exprime sur 32 bits ce qui permet d’adresser jusqu’à 4 Go. Nous
n’expliquerons pas le calcul de l’adresse dans ce mode.
– en mode réel (mode du 8086), les registres de données sont sur 16 bits et les adresses s’expriment sur
20 bits (1 Mo).
Pour solutionner ce problème on utilise une technique appelée ségmentation qui consiste à combiner
deux registres de 16 bits pour obtenir une adresse sur 20 bits suivant la formule :
adresse 20 bits = registre segment × 16 + of f set
L’offset peut être une valeur numérique, un registre ou une combinaison des deux. Toutes les combinaisons entre registre segment et registre index ne sont pas possibles (voir table 2.1).
Registre
Segment
CS
SS
SS
DS
DS
ES
Registre
Pointeur
IP
SP
BP
SI
BX
DI
Compteur ordinal
Sommet de pile
Accès à la pile
TAB . 2.1 – Exemples de combinaisons segment, pointeur
Pour être plus exact, la description de l’offset en mode protégé est donnée par (voir figure 2.4) :
Of f set = [Base] + [Index ∗ Echelle] + deplacement
avec
– base est un registre général 32 bits,
– Index est un registre général 32 bits (excepté ESP) multiplié par un facteur d’Echelle qui est de 1, 2,
4 ou 8. Il est de 1 par défaut,
– déplacement est une constante de 8,16 ou 32 bits
F IG . 2.4 – Spécifiation de l’offset
2.3.3 Types de données
Le Pentium est capable de traiter des quantités allant jusqu’à 64 bits, soit deux doubles mots de 32 bits,
voire jusqu’à 80 bits pour les réels.
29
22 octobre 2005
Dénomination
bit
byte (octet)
word (mot)
double word
quad word
Qté en bits
1
8
16
32
64
Codage Assembleur
DBIT
DB
DW
DD
DQ
TAB . 2.2 – Types de données manipulées en assembleur
2.3.4 Modes d’adressage
L’instruction MOV que nous avons vu précédemment permet de transférer des données entre la mémoire
et un des registres de données. Elle est parfois scindée en deux instructions LOAD et STORE sur les microprocesseurs à architecture RISC. On distingue plusieurs modes d’adressages parmi lesquels :
• l’adressage immédiat consiste à affecter une valeur constante à registre :
MOV AX,1
MOV CL,57
• l’adressage de registre permet de transférer des données entre registres
MOV AX,BX
MOV CL,AL
MOV SI,DI
• l’adressage direct contient l’adresse d’une variable par rapport au segment de base :
MOV SI,OFFSET var SI = offset var
MOV EAX,ES:1FFh
EAX = ES :1FFh
MOV EAX,100
EAX = DS :100
• l’adressage indirect de registre permet d’accéder à la valeur située à une adresse mémoire définie
par un registre :
MOV AX,[SI]
AX = Mem[ SI]
MOV EAX,[EBX+ESI]+4 EAX = Mem[ EBX+ESI+4 ]
2.3.5 Taille des instructions
La taille des instructions varie, par exemple :
8
CALL
16/32
adresse
5
PUSH
3
Reg
2.3.6 Écriture d’un programme Assembleur
Il existe conventionnellement dans les programmes élémentaires écrits en assembleur entre 2 à 3 segments :
– le segment de pile pour lequel on indique la taille de la pile,
– le segment de données dans lequel on définit les variables,
– le segment de code qui contient le code du programme.
Un programme assembleur aura donc la structure suivante :
STACK SEGMENT 4096 ; Pile de 4096 octets
DATA SEGMENT PUBLIC
30
22 octobre 2005
var0 DB ?
var1 DW 1234
var2 DD ?
...
DATA ENDS
CODE SEGMENT PUBLIC
ASSUME DS:DATA, CS:CODE
MOV AX,var0
...
CODE ENDS
2.3.7 Instructions
Dans la suite de cette section nous décrivons les instructions de bases pour écrire des programmes
simples en assembleur.
2.3.7.1 Instructions de chargement : MOV
Les instructions de chargement permettent l’affectation de valeurs entre registres et mémoire.
MOV dst, src
L’instruction MOV attribue la valeur de la source à l’opérande de destination,
MOVSX dst, src
Cette instruction se comporte comme MOV sauf qu’elle permet de convertir une valeur de 8 en 16
bits ou de 16 en 32 bits en une valeur signée,
MOVZX Cette instruction se comporte comme MOV sauf qu’elle permet de convertir une valeur de 8 en 16
bits ou de 16 en 32 bits en une valeur non signée,
Exemples :
MOV EAX,EBX
MOV EAX,ES:1FFh
MOV EAX,100
2.3.7.2 Instructions arithmétiques
Les instructions arithmétiques sont les suivantes :
ADD dst, src
réalise l’addition de deux valeurs
SUB dst, src
réalise la soustraction de deux valeurs
INC dst
incrémente la valeur
DEC dst
décrémente la valeur
NEG dst
réalise le complément à 2 de la valeur
Exemples :
ADD AX,BX
SUB AL,3
NEG ES:[DI]
31
22 octobre 2005
MUL, IMUL src
MUL opère une multiplication non signée entre l’accumulateur et un autre registre ou une valeur,
alors que IMUL réalise une multiplication signée. En fonction de la taille des données on obtiendra
le résultat dans des registres différents :
⋄ AL × 8 bits → AX
⋄ AX × 16 bits → DX :AX
⋄ EAX × 32 bits → EDX :EAX
DIV, IDIV src
DIV opère une multiplication non signée entre l’accumulateur et un autre registre ou une valeur,
alors que IDIV réalise une multiplication signée. En fonction de la taille des données on obtiendra le
résultat dans des registres différents :
⋄ AX / 8 bits → AL quotient, AH reste
⋄ DX :AX / 16 bits → AX quotient, DX reste
⋄ EDX :EAX / 32 bits → EAX quotient, EDX reste
Exemples :
MUL BX
MUL 3
DIV EBX
2.3.7.3 Instructions logiques
AND dst, src
réalise le ET logique
OR dst, src
réalise le OU logique
XOR dst
réalise le OU-exclusif logique
NOT dst
réalise le complément
Exemples :
AND AX,BX
OR AL,3
NOT EAX
2.3.7.4 Instructions de comparaison
CMP dst, src
réalise la comparaison de deux valeurs. On effectue en fait une soustraction entre les 2 valeurs mais
seuls les bits du registres EFLAGS sont positionnés en conséquence.
TEST dst, src
réalise la comparaison de deux valeurs. On effectue en fait un ET logique entre les 2 valeurs mais
seuls les bits du registres EFLAGS sont positionnés en conséquence.
Exemples :
CMP AX,BX
CMP AL,3
TEST AX,1
32
22 octobre 2005
2.3.7.5 Instructions de saut et de branchement
Les instructions
JMP adr
saut à l’adresse adr,
CALL adr
appel de sous-programme,
RET retour de sous-programme,
JE,JZ adr
Jump On Equal, ou Jump on Zero, ZF = 1
JG adr
Jump on Greater Than, SF = OF et ZF = 0
JGE adr
Jump on Greater or Equal, SF = OF
JL adr
Jump on Less, SF 6= OF
JLE adr
Jump on Less or Equal, SF 6= OF ou ZF = 1
Exemples :
CMP AX,BX
CMP AL,3
TEST AX,1
2.3.7.6 Appel de sous-programmes, passage de paramètres et variables locales
Le passage de paramètres à des procédures ou des fonctions est effectué au travers de la pile. Les
variables locales sont également allouées dans la pile. Lors de l’appel d’un sous-programme on réalise les
opérations suivantes :
– on commence par empiler les paramètres du sous-programme sur la pile,
– on empile l’adresse (CS:IP) de la prochaine instruction à exécuter après appel du sous-programme,
– on modifie CS:IP pour lui donner l’adresse du sous-programme,
– on exécute le sous-programme jusqu’à l’instruction RET,
– avec RET on dépile l’adresse de la prochaine instruction à exécuter et on l’affecte à CS:IP.
int sum( int a, int b ) // sous-programme appelé
{
int r;
r = a + b;
return r;
}
int main( ) // sous-programme appelant
{
int res;
res = sum(1,2);
}
A l’intérieur d’un sous-programme on utilise généralement la pile afin d’allouer les variables locales.
Afin de faciliter l’accès aux paramètres et aux variables locales on utilise le registre BP.
33
22 octobre 2005
Adr
Code
102
105
106
109
10A
10D
B8 01 00
50
B8 02 00
50
E8 07 00
...
Instructions (main)
...
MOV AX,1
PUSH AX
MOV AX,2
PUSH AX
CALL sum
...
Adr
114
115
117
11A
11D
120
123
125
126
Code
55
89 E5
83 EC 02
8B 46 06
03 46 04
89 46 FE
89 EC
25
C3
Instructions (sum)
PUSH BP
MOV BP,SP
SUB SP,2 (variable r, équivalent à PUSH AX)
MOV AX,[BP+6]
ADD AX,[BP+4]
MOV [BP-2],AX
MOV SP,BP
POP BP
RET
SP
SP-2
SP-4
SP-6
SP-8
SP-10
1
2
adr1
?
r
BP+6
BP+4
BP+2
BP+0
BP-2
premier paramètre
second paramètres
adresse de retour du sous-programme
ancienne valeur de BP
variable r
TAB . 2.3 – État de la pile et des registres BP et SP lors de l’appel à sum
La pile possède une taille maximale : 4, 8 ou 16 ko en général. Au début le pointeur de pile SP prend la
taille maximale de la pile. Lorsque l’on empile une valeur on décrémente SP. Les instruction PUSH et POP
ont donc le comportement suivant :
– PUSH AX : SP = SP - 2; Mem[SS:SP] = AX,
– POP AX : AX = Mem[SS:SP]; SP = SP + 2.
Lors du retour de sous-programme les paramètres sont toujours présents dans la pile, il faut donc les
supprimer. Il existe ici deux manières de procéder :
– c’est le sous-programme appelant (main) qui supprime les paramètres : dans ce cas, après l’appel de
sum on ajoute l’instruction ADD SP,4,
– c’est le sous-programme appelé (sum) qui supprime les paramètres : dans ce cas on utilise l’instruction RET avec un paramètre : RET 4.
Enfin, lors de l’appel de fonctions, on peut utiliser la pile pour passer la valeur de retour de la fonction
ou un registre comme c’est le cas dans l’exemple précédent.
2.4 Architectures RISC et CISC
Actuellement les microprocesseurs se composent de deux grandes familles :
– les CPU à architecture CISC (Complex Instruction Set Computer)
– les CPU à architecture RISC (Reduced Instruction Set Computer)
La conception d’un microprocesseur pose de nombreux problèmes. Plus la structure du CPU est complexe, plus les procédures de test sont longues et plus il est difficile de déterminer d’éventuels défauts de
conception.
Plusieurs facteurs ont encouragé par le passé la conception de machines CISC :
34
22 octobre 2005
• premièrement, la lenteur de la mémoire par rapport au processeur laissait à penser qu’il était plus
intéressant de soumettre au CPU des instructions complexes. Plutôt que de coder une opération complexe par plusieurs instructions plus petites qui prendraient plus de temps à être chargées depuis la
mémoire, il semblait préférable d’ajouter au CPU une opération complexe qui se chargerait de réaliser
cette opération,
• deuxièmement, le développement des langages de haut niveau (Fortran, Pascal, Ada) a posé de nombreux problèmes quant à la conception de compilateurs capables de traduire des programmes en
langage évolué vers l’assembleur qui soient efficaces. On a donc eu tendance à incorporer au niveau
processeur des instructions plus proches de la structure de ces langages.
En effet dans les années 70 les ordinateurs utilisaient de la mémoire magnétique (réalisée à partir de
tores) pour stocker les programmes. Ce type de mémoire était cher et lent. Un premier changement s’opéra
avec l’arrivée des DRAM mais restait l’épineux problème du prix des DRAM : en 1977 1 Mo de DRAM
coûtait $ 5000 alors qu’il ne valait plus que $ 6 en 1994. Le prix prohibitif des mémoires RAM et la
lenteur des disques faisait qu’un code de programme était considéré comme intéressant s’il était compact.
Le processus de compilation des langages de haut niveau comme Pascal et C était lent et le code assembleur
obtenu n’était pas toujours optimisé : mieux valait coder à la main. Certains proposèrent de combler le
fossé sémantique entre langage de haut niveau et assembleur afin de faciliter la tâche des programmeurs : en
d’autres termes ils proposaient de faire en sorte que les instructions assembleur ressemblent aux instructions
des langages de haut niveau.
– On a toujours considéré que le code provenant d’un compilateur serait toujours moins performant que
le code écrit à la main en assembleur par un programmeur. Soit l’exemple suivant :
void swap(int t[], int k) {
int temp = t[k];
t[k] = t[k+1];
t[k+1] = temp;
}
void sort(int n, int t[]) {
int i, j;
for (i=0; i < n; i++)
for (j=i-1; j >= 0; --j)
if (t[j] > t[j+1]) swap(t,j);
}
Ce morceau de code a été traduit en assembleur par un programmeur et par un compilateur C. Le
code produit par le compilateur C a obtenu un meilleur résultat à l’exécution :
Traducteur
Temps
Assembleur (à la main) 37.9 s
Compilateur C
25.3 s
– l’Intel 8086 possède un préfixe REP qui peut être accolé à certaines instructions afin de les utiliser de
manière itérative. Si on désire transférer un bloc de données d’une adresse mémoire à une autre, deux
solutions s’offrent à nous, mais la plus simple n’est pas forcément la meilleure.
Transfert par REP
Transfert par boucle
sur des entiers
sur des entiers
MOV CX,size
MOV CX,size
MOV SI,src
MOV SI,src
MOV DI,dst
MOV DI,dst
REP MOVSB
j1: MOV AL,[SI]
MOV [DI],AL
INC SI
INC DI
DEC CX
JNZ j1
40 Mo/s
60 Mo/s
35
22 octobre 2005
Dans au milieu des années 70, deux facteurs sont venus ébranler les idées ancrées dans les esprits par
les décennies précédentes :
• d’une part les mémoires sont devenues plus rapides qu’elles ne l’étaient auparavant,
• d’autre part, des études réalisées par Knuth (1971), Wortman (1972) et Patterson (1982) conduites
sur des langages de haut niveau montrèrent que
– les programmes sont constitués à 85 % d’affectations, d’instructions if et d’appels de procédures,
– 80 % des affectations sont de la forme variable = valeur.
Les résultats précédents peuvent se résumer par la phrase suivante : 80 % des traitements des langages
de haut niveau font appel à 20 % des instructions du CPU. D’où l’idée d’améliorer la vitesse de traitement
des instructions les plus souvent utilisées.
Les machines RISC se distinguent des machines CISC par le fait que les instructions sont exécutées en
un cycle d’horloge.
RISC
instructions simples ne prenant qu’un seul
cycle
seules les instructions LOAD et STORE
ont accès à la mémoire
instructions au format fixe
beaucoup de registres
peu de modes d’adressage
CISC
instructions complexes prenant plusieurs
cycles
toutes les instructions sont susceptibles
d’accèder à la mémoire
instructions au format variable
peu de registres
beaucoup de modes d’adressage
TAB . 2.4 – Caractéristiques comparées des architectures RISC et CISC
Le principe qui participe à la conception des architectures RISC est simple : tout faire pour que le temps
de cycle du chemin des données soit le plus court possible.
Le temps de cycle du chemin des données est constitué par :
– le transfert des données entre mémoire et registres du CPU
– le transfert des données entre registres du CPU et opérandes de l’UAL
– la réalisation des calculs par l’UAL
En fait le terme Réduit de l’appellation RISC est plutôt mal choisi. Si les processeurs RISC ont moins
d’instructions que les processeurs CISC c’est une conséquence directe du fait que les modes d’adressages
(cf. section 2.3.4) en RISC sont beaucoup moins nombreux que ceux des processeurs CISC : de fait le
système de codage des instructions est allégé. Mais ce qui importe surtout c’est que l’on cherche à exécuter
une instruction par cycle d’horloge.
La relative simplicité des processeurs RISC influe sur le nombre de transistors nécessaires à leur conception. Un microprocesseur RISC contient donc bien moins de transistors (à la base) qu’un processeur CISC.
La place restante sur le die peut alors être occupée par un nombre important de registres ainsi qu’un cache
de premier niveau.
2.4.1 Gestion des registres en RISC
Afin de minimiser les accès à la mémoire les machines RISC utilisent un grand nombre de registres
(512 pour le Motorola 68030). Si on devait réaliser le codage des instructions en codant les 512 registres
on perdrait beaucoup de place. Au lieu de cela on utilise une technique qualifiée de fenêtre glissante de
registres mise au point par Patterson et Séquin en 1982 (cf. figure 2.5).
À chaque instant le processeur voit 32 registres qui sont généralement répartis en 4 × 8 registres :
– registres réservés aux variables globales du programme
– regisres pour les paramètres entrant des procédures. S’il y a plus de 8 paramètres le reste des paramètres est placé dans la pile
– registres pour les variables locales
– registres pour les paramètres sortants
En fait seuls les registres globaux ne changent pas. Par contre les autres registres glissent à chaque nouvel appel de procédure. Pour garder la cohérence il y a recouvrement des registres sortants d’une procédure
36
22 octobre 2005
R
0
Globaux
R
R
Globaux
Globaux
7
8
Entrée
R
15
R
16
R
R
R
Locaux
appel
procédure
Sortie
Recouvrement
23
24
Entrée
31
Locaux
appel
procédure
Sortie
Recouvrement
Entrée
Locaux
Sortie
F IG . 2.5 – Fenêtre glissante de registres en RISC
avec les registres entrant de la suivante. Lorsqu’il n’y plus de registres disponibles on sauvegarde des registres de la première fenêtre en mémoire et on continue. Les registres sont donc gérés par un buffer circulaire.
Cette technique est tout à fait intéressante puisqu’elle minimise les accès mémoire. Elle pourrait également
être utilisée dans le cadre d’une architecture CISC.
2.5 Amélioration des CPU
2.5.1 Généralités
Le temps d’exécution d’un programme est donné par la formule suivante :
Texec = Nins × CP I × Tcycle
– Texec : temps d’exécution,
– Nins : nombre d’instructions,
– CP I : nombre de cycles par instructions,
– Tcycle : temps de cycle (ns)
Les différentes évolutions des ordinateurs ont pour but de diminuer le temps d’exécution des programmes.
⊲ la première amélioration consiste à diminuer le temps de cycle pour cela il suffit d’augmenter la
fréquence des processeurs. Grossièrement, un processeur à 3 Ghz fonctionne 3 fois plus vite qu’un
processeur à 1 Ghz.
⊲ on peut ensuite diminuer le nombre d’instructions ou le nombre de cycles par instructions. Or dans
ce cas, il semble que le produit Nins × CP I reste constant :
– en effet si on diminue le nombre d’instructions on crée des instructions plus complexes (CISC) qui
nécessitent plus de cycles pour être exécutées.
– si par contre on diminue le nombre de cycles par instructions on crée des instructions simples
(RISC) et il faut utiliser plusieurs instructions pour réaliser le même traitement qu’une instruction
CISC.
Il a donc fallu élaborer des solutions capables de diminuer le temps nécessaire au traitement des instructions qu’elles soient CISC ou RISC.
37
22 octobre 2005
2.5.2 Traitement de base
16 cycles
UE
A
B
C
D
E
F
G
H
F IG . 2.6 – Traitement des instructions par une seule unité d’exécution
Comme le montre la figure 2.6, dans un schéma de traitement des instructions classique, les instructions
sont traitées de manière séquentielle par une seule unité d’exécution (UE).
2.5.3 Processeurs Superscalaires
La technologie superscalaire consiste à doter le CPU de plusieurs unités d’exécution (voir figure 2.7).
On trouve actuellement cette technique présente sur un grand nombre de microprocesseurs : PowerPC,
UltraSparc, PA 9000, Pentium, .... Le but recherché est d’exécuter plusieurs instructions en parallèle. Il faut
donc pouvoir soutenir un flot important d’instructions et pour cela disposer d’un cache (L1) performant.
8 cycles
UE1
UE2
A
C
E
B
D
F
G
H
F IG . 2.7 – Traitement des instructions avec 2 unités d’exécution
Les processeurs actuels sont dotés de plusieurs unités d’exécution sur les entiers et les réels.
2.5.4 Architecture Pipeline
Les instructions (mnemonics) des processeurs ne sont pas exécutables directement. Elles sont décomposées
en micro-opérations (µOP ) interprétables par les différentes unités d’exécution du CPU. Ainsi, une instruction assembleur peut être traduite en 1 à 100 µOP . L’exécution d’une instruction passe ensuite par les étapes
suivantes :
– Fetch (Load instruction) : chargement de l’instruction pointée par le CO (Compteur Ordinal) dans
le RI (Registre d’Instruction)
– Decode : décodage de l’instruction, traduction en µOP
– Load operand : calcul de l’adresse des opérandes et chargement depuis la mémoire ou un registre
– Execute : exécution de l’instruction (ALU, FPU)
– Write result : écriture du résultat en mémoire ou mise à jour des registres
Chaque étape peut prendre entre 1 et plusieurs cycles d’horloge. On essaye généralement de faire en
sorte que chaque étape ne prenne qu’un seul cycle sauf pour les accès mémoire qui prennent plusieurs
cycles.
Dans un cycle d’exécution classique, une instruction réalise les 5 étapes précédentes, puis on passe
à l’instruction suivante. L’idée du pipeline consiste à exploiter le parallélisme des différentes étapes de
traitement des instructions : une fois qu’une instruction passe dans la phase decode, la suivante peut passer
dans la phase fetch (cf. figure 2.8).
Le gain obtenu dépend de la profondeur (on dit aussi nombre d’étages) du pipeline. Pour exécuter n
instructions de manière séquentielle, chaque instruction s’exécutant en k cycles d’horloge, il faut n × k
cycles d’horloge au total. Si on utilise un piepline de k étages, il faut k cycles d’horloge pour exécuter la
38
22 octobre 2005
I1 F 1 D 1 M 1 E 1 W 1
F2 D2 M2 E2 W2
I2
F3 D3 M3 E3 W3
I3
Modèle
Classique
1
2
3
4
5
6
7
8
9
I1 F 1 D 1 M 1 E 1 W 1
Modèle
Pipeline
I2
I3
I4
I5
F2 D2 M2 E2
F3 D3 M3
F4 D4
F5
W2
E3 W3
M4 E4 W4
D5 M5 E5 W5
F IG . 2.8 – Traitement des instructions avec un pipeline
première instruction puis n − 1 cycles pour les n − 1 instructions suivantes. Le gain obtenu est donc de
g=
n×k
k+n−1
Lorsque n est grand par rapport à k, g ≃ k. Pour l’Athlon d’AMD le pipeline est composé de 11 étages.
Pour les Pentium 2, 3 et 4 d’Intel, le nombre d’étages est respectivement de 12, 10 et 20.
2.5.4.1 Problèmes liés aux pipelines
Dans une situation idéale le pipeline est alimenté de manière continue. Cependant, en situation réelle, il
est difficile de maintenir un débit maximal dans le pipeline en raison de différents problèmes :
– Les instructions CISC complexes prennent du temps à être décodées. Pendant que les décodeurs
travaillent le pipeline ne peut pas être alimenté.
– Certaines données sont en cours de traitement et ne peuvent être utilisées : il s’agit de problèmes de
dépendances.
– Les conflits d’accès à la mémoire peuvent retarder la progression des µOP dans le pipeline.
– Les branchements sont également une source de problèmes pour l’alimentation du pipeline qui doit
être alors réinitialisé.
2.5.4.2 Dépendance de données
Soit le code suivant :
I1 ADD AX,BX
I2 MUL CX
Pour que le résultat soit cohérent il faut que l’instruction I1 soit terminée avant le début de l’instruction
I2 . Il s’agit ici d’une dépendance appelée RAW (Read After Write). Il faut que l’étape W1 soit terminée
pour pouvoir exécuter D2 et charger les opérandes avec la valeur de AX (cf. figure 2.9). En ce qui concerne
le pipeline cela implique que le pipeline est inactif pendant un certain nombre de cycles.
1
2
3
4
5
6
7
8
9
10
I1 F 1 D 1 M 1 E 1 W 1
I2
F2
D2 M2 E2 W2
I3
I4
I5
F3 D3 M3 E3 W3
F4 D4 M4 E4 W4
F5 D5 M5 E5 W5
F IG . 2.9 – Influence des dépendances sur le pipeline
Pour résoudre ce genre de problème plusieurs solutions existent (voir figure 2.10) :
39
22 octobre 2005
– la première consiste pour le compilateur à insérer dans le code des instructions NOP, dont le but est
de ne rien faire afin de retarder l’exécution de la prochaine instruction.
– la seconde va réordonner les instructions : si les instructions suivantes ne possèdent pas de dépendances
avec l’instruction I1 par exemple. Le réordonnancement peut être effectué par un compilateur ou par
le processeur, on parle alors de gestion non-ordonnée des instructions (out of order). Il faut pour cela
disposer d’un stock d’instructions à examiner.
– la troisième consiste à faire du forward after execute, c’est à dire qu’on attend pas que l’instruction
soit totalement terminée pour propager ses résultats à d’autres étages du pipeline.
1
Réarrangement
des instructions
2
3
I1 F 1 D 1 M 1
F3 D3
I3
F4
I4
I5
I2
4
5
E1
M3
D4
F5
W1
E3 W3
M4 E4 W4
D5 M5 E5 W5
6
7
8
9
10
F2 D2 M2 E2 W2
F1 D1 M1 E1 W1
Forward
after
Execute
F2 D2 M2 E2 W2
F3 D3 M3 E3 W3
F IG . 2.10 – Solutions pour les dépendances sur le pipeline
2.5.4.3 Dépendance dues à des branchements conditionnels
I1 loop : MOV AX,[SI]
I2
MOV [DI],AX
I3
ADD SI,2
I4
ADD DI,2
I5
DEC CX
I6
JNZ loop
I7
MOV AX,1
I8
MOV BX,[100]
...
Lors de l’exécution de l’instruction I6 , si CX est égal à 0, c’est l’instruction suivante I7 qui sera exécutée.
Par contre lorsque CX n’est pas égal à 0 (ce qui est le cas souvent puisqu’il s’agit d’une boucle), il faut se
rendre à l’adresse loop et donc supprimer les instructions I7 et I8 qui sont déjà dans le pipeline.
Lors d’un branchement il faut calculer l’adresse de destination avant de mettre à jour le compteur ordinal. Il faudra ensuite, si le branchement est effectué éliminer les instructions déjà présentes dans le pipeline
et les remplacer par une nouvelle séquence d’instructions. Or plus le pipeline est profond plus il faut de
temps pour le vider. La solution réside dans la prédiction de branchement.
Prédiction de branchement La prédiction de branchement consiste à prédire quelle sera la prochaine
branche du programme à exécuter. On utilise un algorithme mathématique basé sur des calculs statistiques
et deux tableaux le BTB et le BHT :
– BTB - Branch Target Buffer contient les adresses mémoires des branches d’un programme,
– BHT - Branch History Table retrace les choix de décisions pour chaque branchement.
Le Pentium 3 possède un BTB de 512 octets alors que le Pentium 4 a un BTB de 4 ko.
2.5.4.4 Combiner pipeline et superscalaire
Comme le montre la figure 2.11, deux architectures de pipeline sont possibles :
40
22 octobre 2005
Front End
Architecture G4
Architecture P4
F IG . 2.11 – Architectures de pipelines
– la première est celle du Power G4 pour laquelle le Front End est capable de traiter 16 instructions qui
alimentent de nombreux petits pipelines,
– la seconde architecture est celle du Pentium 4 pour laquelle le Front End de 126 instructions alimente
quelques pipeline profonds.
Pour comprendre les avantages et inconvénients liés à ces deux architectures on peut prendre l’analogie
du McDonald1.
2.5.5 Processeurs Vectoriels
On peut également combiner le pipelining avec les processeurs vectoriels. Il s’agit de processeurs SIMD
(Single Instruction Multiple Data) capables d’effectuer une opération de manière répétitive sur plusieurs
données différentes (exemple somme ou produit vectoriel de vecteurs). Dans ce genre de processeur on
dispose de registres vectoriels capables de stocker un ensemble de données, d’opérer des calculs entre ces
données et de stocker ensuite le résultat en mémoire une fois le calcul effectué.
Les processeurs actuels intègrent des unités de calcul vectoriel dédiées au multimédia :
MMX (Multi-Media eXtention) a été la première unité de calcul intégrée au processeur Pentium MMX.
Ses registres ont une taille de 64 bits et ne travaillent que sur des entiers.
SSE (Streaming Simd Extension) est apparue sur les Pentium 3. Elle est composée de 70 instructions,
dispose de registres 128 bits et travaille sur les entiers ou les flottants (en 32 bits).
SSE2 évolution de SSE pour les Pentium 4, comporte 144 nouvelles instructions et gère les flottants
sur 64 bits.
3DNow ! il s’agit de la version MMX/SSE des processeurs AMD apparue sur les K6-II. Ses registres
ont une taille de 64 bits.
2.5.6 Le VLIW
L’approche VLIW (Very Long Instruction Word, cf. figure 2.12) peut être considérée comme une mise
en oeuvre de l’architecture superscalaire et consiste à utiliser des mots de longueur assez grande (128, 256
ou 1024 bits par exemple) et à y coder plusieurs instructions à la fois qui seront exécutées en parallèle. Dans
cette approche, proposée par Josh Fisher en 1980 (Yale), c’est le compilateur qui est chargé d’arranger les
instructions dans un mot. La complexité des circuits de décodage est telle que le VLIW atteint ses limites
au delà de 5 ou 6 instructions à exécuter en parallèle.
1 The
Pentium 4 and the G4e : an Architectural Comparison, Jon Hannibal Stokes, ArsTechnica, July, 2001.
41
22 octobre 2005
U.E 1
Modèle classique
U.E 2
U.E 3
Flux d’instructions
U.E 1
U.E 2
VLIW
U.E 3
F IG . 2.12 – Comparaison modèle classique (superscalaire) et VLIW
2.6 Mesure des performances des processeurs
Pour mesurer les performances des processeurs on utilise des unités élémentaires appelées Mips et
MFlops
• Le Mips (Million of Instructions Per Second) mesure le nombre d’opération sur des nombres entiers
qu’un processeur est capable d’effectuer en 1 seconde,
• Le MFlops (Million of Floating point Operations Per Second) mesure le nombre d’opérations en
virgule flottante qu’un processeur est capable d’effectuer en 1 seconde. On parle également de GFlops
(GigaFlops), TFlops (TéraFlops) et PFlops (PétaFlops)
Ces deux grandeurs sont cependant dépendantes des architectures des CPUs et il est difficile de comparer des résultats entre RISC et CISC. Certains constructeurs se sont regroupés formant une association
nommée SPEC (System Performance Evaluation Cooperative) créée en 1989 qui a pour objectif de définir
des mesures standard communes. Ils disposent d’une batterie de tests de référence (benchmarks) baptisés
SPECint pour les entiers et SPECfp pour les nombres en virgule flottante.
Il existe aussi le whetstone et le dhrystone ainsi que les tests Linpack ou plus spécifiquement les WinBench, Winstone96.
• le Whetstone est basé sur des calculs scientifiques réalisés en Fortran,
• le Dhrystone est inspiré du Whetstone, il fut réalisé en Ada puis réécrit en C,
• Linpack regroupe un certains nombre de tests reliés au calcul matriciel (produit, inversion, résolution
de systèmes, ... ). Les programmes sont écrits initialement en Fortran mais on trouve aujourd’hui des
versions C.
il existe également un certain nombre d’utilitaires et benchmarks de référence qui concerne l’audio, la
vidéo, les jeux :
• LAME (encodage MP3)
• Super PI (calcul des décimales de PI)
• 3DMark (mesure des performances des cartes graphiques)
2.6.1 HyperThreading et Multi-cores
L’HyperThreading est une simulation de processeur multi-cores. Actuellement les processeurs sont
dotés d’un seul coeur (core), c’est à dire que l’on ne peut traiter qu’un seul flux d’instructions. Avec l’arrivée
de l’HyperThreading sur les Pentium 4 Northwood on est en fait capable de traiter 2 flux d’instructions soit
2 programmes en paralèle. Cependant l’HyperThreading consiste à traiter les instructions de deux flux en
les réorganisant de manière à simuler un traitement en parallèle.
L’arrivée des processeurs multi-core sur un même die devrait apporter un gain de performance notable
mais uniquement si les performances des mémoire suit également une amélioration. Dans le cas des processeurs multi-cores, chaque core dispose de ses propres cache L1 et L2.
Intel, AMD et SUN prévoient de mettre au point des processeurs composés de 2, 4, 8 ou 16 cores
42
22 octobre 2005
2.7 L’architecture AMD64
Alors qu’Intel a complétement modifié l’architecture de ses processeurs Itanium lors du passage au 64
bits, AMD a fait le choix de garder la compatibilité avec les processeurs 32 bits actuels en donnant naissance
à l’architecture AMD64. C’est un choix économique et technologique qui semble porter ses fruits. Intel a
ensuite suivi le chemin tracé par AMD, avec la technologie EM64T.
Ainsi les processeurs basés sur la technologie AMD64 peuvent évoluer dans deux modes différents :
– le mode legacy qui correspond au 32 bits
– le mode long qui correspond au 64 bits décomposé en deux sous modes : Compability et 64-bit
2.7.1 Les registres
L’Athlon XP est basé sur une architecture IA32 et comporte 8 registres généraux (EAX à EDI) et 8
registres 80 bits (FPU). Sur l’Athlon 64 on dispose en 64 bits de :
• 16 registres 64 bits (RAX à RDI) + 8 registres suplémentaires R8 à R15,
• 16 registres SSE2 XMM0 à XMM15 de 128 bits
F IG . 2.13 – Registre en 64 bits (Source AMD)
F IG . 2.14 – Mode Register Memory
• Le codage IA32 des registres utilise le bit ModRM (Mode/Register/Memory) pour lequel 3 bits sont
utilisés pour coder le registre, champ reg (voir figure 2.14). Afin de ne pas endiguer la compatibilité
avec l’architecture IA32, on utilise un bit du champ Register/Memory
43
22 octobre 2005
F IG . 2.15 – Mode d’exécution (Source AMD)
2.7.2 Le contrôleur mémoire
Le northbridge est intégré directement sur le die du processeur
2.7.3 L’HyperTransport
L’hypertransport est un bus de communication série de haut niveau capable d’assurer la liaison entre
différents processeurs et contrôleurs en modulant son débit. Il fonctionne à 800 Mhz sur 16 bits avec une
technologie DDR ce qui lui permet d’atteindre 3,2 Go/s dans 2 directions soit un total de 6,4 Go/s. L’hypertransport est une technologie client/serveur alors que les autres technologies sont de type point à point.
44

Microprocesseurs

Transcription

Documents pareils

contrôle continu 2008-2009 - Département Informatique

Recueil de sperme pour analyse 1. OBJET/ DOMAINE D

fours a gaz, modeles de plancher

Fiche technique Sanilav 316-5-Z3

Fiche technique KOLDY

Département de génie électrique et de génie informatique Etienne

reversible glass door ports en verre réversible

felt pad attachment coussins en feutre

Fiche technique SURCHPO