Architecture des Ordinateurs
2ème année Ingénieurs en Informatique
Nejib Ben Hadj-Alouane
Architecture des Ordinateurs 2
CHAPITRE I
Introduction
Architecture des Ordinateurs 3
• 17è siècle, calcul arithmétique simple: addition, soustraction …
• PASCAL (1623-1662) effectue mécaniquement des additions et des soustractions
• LEIBNIZ (1646-1716) envisage qu’une machine puisse raisonner
• CHARLES BABBAGE (1792-1871) a construit en 1833 une machine à calculer: la machine à différences. – Programmable avec un langage assembleur très
simple– ADA AUGUSTA LOVELACE, collaboratrice de BABBAGE et
fille de LORD BYRON, écrit le premier programme informatique.
Historique
Architecture des Ordinateurs 4
Historique
• 1945 : ENIAC (Electronic Numerical Integrator And Calculator) – 18 000 tubes– 30 tonnes– multiplie 2 nombres de 10 chiffres en 3
millisecondes– données sur cartes perforées, mais
programmes câblés– en mémoire et donc, pour passer d’un
programme à un autre, il faut débrancher et rebrancher des centaines de câbles (ce n’est pas vraiment le premier ordinateur au sens actuel).
Architecture des Ordinateurs 5
Historique
• 1945 : JOHN VON NEUMANN, associé à l’ENIAC, propose un modèle d’ordinateur qui fait abstraction du programme et se lance dans la construction du EDVAC (Electronic Discrete Variable Automatic Computer)
• La machine de VON NEUMANN est née:– Consiste en cinq composants de l’architecture
moderne, appelée architecture de VON NEUMANN.
Architecture des Ordinateurs 6
Historique
• Première génération (1945-1955) : tubes à vide– Tubes à vide: pannes fréquentes, difficiles à
déceler, ordinateurs demandant beaucoup de place.
• Deuxième génération (1955-1965)– Transistors: organisation de la machine
autour d’un bus ; stockage sur bande magnétique ; écrans ; etc.
• Troisième génération (1965-1980) – Circuits intégrés (puces) et des processeurs
miniaturisation (ordinateurs plus petits, plus rapides et moins chers)
Architecture des Ordinateurs 7
Historique– Gammes de machines avec même langage
d’assemblage, d’où réutilisation des programmes.
– Multiprogrammation: plusieurs programmes en mémoire. Lorsqu’un programme entre en phase d’entrées-sorties, l’UC passe à l’exécution d’un autre programme.
• Quatrième génération (à partir de 1980) – Ordinateurs personnels et VLSI (Very Large Scale Intégration) : augmentation du nombre de transistors ; réseaux …
• Parallèles, intelligents...
Architecture des Ordinateurs 8
Classification des ordinateurs
• Superordinateurs (5 à 20M$)–Grande pièce, applications scientifiques
et militaires titanesques (éléments finis, météo...)…
– CRAY 2, NEC SX-2, Hitachi, IBM... • Serveurs d'entreprise, mainframe (1
à 5 M$)– Grosses bases de données avec de
nombreux usagers (banques, réservations de lignes aériennes...)
– IBM ES/9000, CDC, AT&T NCR, Pyramid, Sequent, Unisys, DEC, HP, SUN.
Architecture des Ordinateurs 9
Classification des ordinateurs
• Serveurs départementaux (50K$ à 1 M$)– Grande pièce, applications scientifiques et
militaires titanesques (éléments finis, météo...)– CRAY 2, NEC SX-2, Hitachi, IBM...
• Serveurs d'entreprise, mainframe (1 à 5 M$)– Grosses bases de données avec de nombreux
usagers (banques, réservations de lignes aériennes...)
– IBM ES/9000, CDC, AT&T NCR, Pyramid, Sequent, Unisys, DEC, HP, SUN.
Architecture des Ordinateurs 10
Classification des ordinateurs
• Serveurs départementaux (50K$ à 1 M$)– Serveurs de fichiers, de bases de données, de calcul pour
un groupe d'environ 100 personnes ou moins.– DEC, HP, SUN, IBM, SGI, Data General...
• Poste de travail (workstation), (4K$ à 50K$)– CAO, développement de logiciel, graphisme, multimédia, – SUN, HP, IBM, DEC, SGI, NeXT...
• Micro-ordinateur (100 à 4 K$)– Bureautique, simple (traitement de texte, administration,
jeux...)– IBM, APPLE, HP, Dell,…
Architecture des Ordinateurs 11
Objectifs du cours• Les notions suivantes sont traitées:
– Conception et architecture de l’ensemble des instructions (ISA)
– Familiarisation avec les opérations du niveautransfert registres
– Organisation du matériel en tant que chemin de données et unité de contrôle
– Assemblage des composants pour construction des différents types de chemins de données du processeur
– Différents types de conception et d’unité de contrôle – Organisation et conception du système mémoire
Architecture des Ordinateurs 12
Notions d’architecture
Architecture des Ordinateurs ?
Architecture de l’ensemble d’instructions de la machine +
« Organisation de la machine »
• Architecture de l’ensemble d’instructions– Organisation d’éléments mémoires (registres, caches,…).– Représentation des types de données et structure de
données. – Ensemble d’instructions et leurs formats. – Modes d’adressage et types d’accès aux éléments data et
instructions.
– Autres conditions exceptionnelles de la machine (Interruptions, erreurs,…).
Architecture des Ordinateurs 13
LangagesEchange (int v[],int k,int k’){int temp ;temp = v[k] ;v[k] = v[k’];v[k’] = temp;} Compilateur C
Change:multi $2, S5, 4;add $2, $4, $2;….
Assembleur
0000000010100001000000000001100000000000100011100011000000100001….Programme en langage machine binaire
(pour MIPS)
Programme en langage assembleur(pour MIPS)
Programme en langage de haut niveau(en C)
Architecture des Ordinateurs 14
Ensembles d’instructions
• Exemples d’ensembles d’instructions– Digital alpha – HP PA-RISC– SUN SPARC– SGI MIPS– INTEL (IA-32, …)
• Les caractéristiques d’un ensemble d’instructions seront introduites par la suite à travers l’étude d’un ensemble réel d’instructions: MIPS.
Architecture des Ordinateurs 15
Notions d’architecture
Ordinateur personnel
Processeur
Ordinateur
Contrôle
Chemin dedonnées
Mémoire
(programmesen exécution)
Entrées
Sorties
Clavier, Souries
Ecran , Imprimante
Disque dur
Architecture des Ordinateurs 16
Evolutions technologiques
1985 : Invention du processeur sur une seule puce et de l’ordinateur sur une seule plaque (PC, Stations de travail, …)
Processeur : (Chaque 1.5 année depuis 85)
Mémoire : (Chaque 2 ans depuis 96)
Capacité : 2X (DRAM)
(64X, dernière décennie)
Disque dur : (Chaque année)
Capacité : 2X
(250X, dernière décennie)
2X en vitesse
Architecture des Ordinateurs 17
Fonction d’architecte
• Coordination entre plusieurs niveaux d’abstraction
Système d’E/SProcesseur
CompilateurSystème d’exploitation
(Windows 2K)
Application (Netscape)
Digital DesignCircuit Design
Architecture de l’ensemble d’instructions
Chemin de données & Contrôle
transistors
MémoireHardware
Software Assembleur
Architecture des Ordinateurs 18
Fonction d’architecte
• Prévoir l'évolution
–Au moment de l'étude de marché, le concepteur doit prévoir l’état de la compétition au moment où le nouvel ordinateur arrivera sur le marché.
Architecture des Ordinateurs 19
Références• Principales
– David Patterson et John Hennessy. Organisation et conception des ordinateurs, Dunod, 1994.
– David Patterson and John Hennessy. Computer Organisation and Design, 2nd edition, Morgan Kaufman Publishers, Inc., 1997.
• Autres– J. L. Hennessy and D. A. Patterson. Architecture des ordinateurs: une approche quantitative. 3ème
édition, Vuibert Informatique, 2003.
– Dominic Sweetman. See MIPS Run, 2nd edition, Morgan Kaufman Publishers, Inc. , 2003.
Architecture des Ordinateurs 20
Plan du cours
Chapitre Contenu Référence livre Durée
CHAPITRE IIntroduction
Introduction à l’architecture des ordinateurs, évolution, composants d’un ordinateur,…
Appendix B. 1 séance.
CHAPITRE IIRappels systèmes logiques
Rappel de notions de base des systèmes logiques, Banc de registres, Multiplexeurs, …
Chapitre 1. 1 séance.
CHAPITRE IIIMIPS ISA
Modes d’adressage, formats d’instructions, les composants du MIPS ISA, le jeu d’instructions MIPS lite.
Chapitre 3.Appendix A.
2 séances.
Architecture des Ordinateurs 21
Plan du cours
Chapitre Contenu Référence livre Durée
CHAPITRE IVConception des unités arithmétiques
Construction d’UAL. Approche de conception « Top Down » et « Bottom Up »
Chapitre 4. 1 séance.
Algorithmes est chemins de données pour multiplication et division des entiers
2 séances.
Architecture des Ordinateurs 22
Plan du cours
Chapitre Contenu Référence livre Durée
CHAPITRE VConception de microprocesseur mono-cycle(MIPS lite)
Chemin de données. Chapitre 5. 1 séance.
Unité de contrôle. 1 séance.
CHAPITRE VIConception de microprocesseur multi-cycles(MIPS lite)
Chemin de données. Chapitre 5. 1 séance.
Unité de contrôle: implémentation câblée.
1 séance.
1 séance.
Architecture des Ordinateurs 23
Plan du cours
Chapitre Contenu Référence livre Durée
CHAPITRE VIIConception de microprocesseur en pipeline(MIPS lite)
Notions d’exécution en pipeline.
Chapitre 5 1 séance.
Aléas de pipeline et méthodes résolutions.
1 séance.
Notion de chemin de données en pipeline.
1 séance.
CHAPITRE VIIISystèmes de mémoire
Technologies et types de mémoires.
Chapitre 7. 1 séance.
Intégration des caches 1 séance.
Architecture des Ordinateurs 24
CHAPITRE II:
Rappel systèmes logiques
Architecture des Ordinateurs 25
Logique combinatoire
• Variables d’entrées:– Variables logiques indépendantes.
• Variables de sorties:– Variables contenant l’état de la fonction après l ’évaluation des
opérateurs logiques sur les variables d’entrées.
• Opérateurs logiques:– ET : z = u1.u2=u1u2, z est vraie si u1 est vraie et u2 est vraie.
– OU : z = u1+u2, z est vraie lorsque u1 est vraie ou u2 est vraie, ou les deux.
– NON : z = u, z est vraie si u est fausse.
Architecture des Ordinateurs 26
Logique combinatoire Les portes logiques associées à ces opérateurs sont représentées comme suit :
(ET)AND (OU)OR (NON)NOT
Portes universelles :
Porte NAND (NON-ET) et porte NOR (NON-OU)
x y
x y
(c) NON-ET (d) NON-OU
x⋅y x+y
Portes Xor et XNor
Architecture des Ordinateurs 27
Logique combinatoire
Exemple : Fonction à trois entrées u1,u2 , et u3 et deux sorties x1 et x2 est représentée par la table de vérité suivante.
u1 u2 u3 x1 x2
0 0 0100
0 1 0110001
1 0 1011111
01111111
00010110
23 entrées
x1 = u1 + u2 + u3
x2 = u1u2u3+ u1u2u3 + u1u2u3
Architecture des Ordinateurs 28
Logique combinatoireLois de Morgan : (Transformation d’équations logiques)
u + v = u v
u v = u + v
1. Somme de produits
x1 = u1u2u3 + u1u2u3 +u1u2u3 +u1u2u3 + u1u2u3 +u1u2u3 +u1u2u3
2. Produit de Sommes
x1 = u1+ u2+u3
Sorties d’une fonction combinatoire:
Formes canoniques utiles pour implémentation avec deux niveaux de portes
Architecture des Ordinateurs 29
Multiplexeur
MUX
u1 0
u2 1
S
y
y = (u1.S)+(u2.S)
MUX
u1 0
u2 1
S1
yu3 2
u4 3
S2
Sélectionner une parmi 2n entrées et la transmettre à la sortie.La sélection est faite à l’aide de n lignes d’adresse. La notionusuelle de MUX est : MUX 2n à 1. Par exemple, un MUX 8 à 1aura trois lignes d’adresse.
Architecture des Ordinateurs 30
DécodeurTraduit l’entrée sur n bits en un signal correspondant à sa valeur binaire
Décodeur3
S1
S0
S7
S3
S2
S4S5S6
S7 S6 S5E2 E1 E0 S4 S3 S2 S1 S0
0 0 0 0 0 0 0 00 0 0 10 0 1 0 0 0 0 00 0 1 0
0 1 0 0 0 0 0 00 1 0 0
0 1 1 0 0 0 0 1 0 0 0
1 0 0 0 0 0 1 00 0 0 0
1 0 1 0 0 1 0 00 0 0 0
1 1 1 1 0 0 0 00 0 0 01 1 0 0 1 0 0 00 0 0 0
Décodeur 3 pour 8
Architecture des Ordinateurs 31
Réseau logique programmable (RLP)
Un Réseau Composé de portes AND suivi d’un réseau composé de portes OR
u1
u2
u3
x1
x2x1 = ?
x2 = ?
Architecture des Ordinateurs 32
Réseau Logique Programmable (RLP)
Représentation Simplifiée
u1
u2
u3
x1
x2
Architecture des Ordinateurs 33
Mémoire morte (ROM)
• Réalisation de fonctions logiques. • Ensemble d’emplacements qui peuvent être
lus. • Matrice de cellules capable de stocker de
l’information unitaire (bit)• Ensemble de lignes d’adresse et un ensemble
de sorties• ROM codifie directement à partir de la table
de vérité un ensemble de fonctions logiques
• n fonctions à m entrées (ROM à m lignes d’adresse, 2m entrées, entrée (n bits))
Architecture des Ordinateurs 34
Horloges • Synchronisation.
• Logique séquentielle pour spécifier à quel moment
un élément qui contient un état doit être mis à jour.
• Les instants de stabilités des valeurs d’un circuit.
Période ou cycle
Front montant Front descendant
Architecture des Ordinateurs 35
Horloges• Synchronisation par niveau (haut ou bas)
• Synchronisation par front (montant ou descendent)
• Front actif (montant ou descendent) ⇒ changement d’état
Système à horloge (système synchrone)
Élément d’état 1
Élément d’état2
Logique combinatoire
Cycle d’horloge Limite inférieure sur la période d’horloge
Architecture des Ordinateurs 36
Éléments mémoires• Bistables et bascules
• Registres
• Mémoires
• Bascule RS (asynchrone)
Q
Q
Set / Reset
S = 1 → Q = 1
R = 1 → Q = 0
S = 0, R = 0 → valeur précédente de Q
S = 1, R = 1 → état illégal
R
S
Architecture des Ordinateurs 37
Éléments mémoires
• Bascule – bistable (synchrone)
– Différence entre bistable et bascule (moment où l’horloge provoque le changement d’état actif)
– Bascule synchrone (état modifié à chaque fois que les entrées changent et que l’horloge est à 1)
– Bistable synchrone (état n’est modifié que sur un front d’impulsion de l’horloge)
Architecture des Ordinateurs 38
Bascule D (synchrone / niveau)
QC
DQ Stocker un signal
Horloge C = 1 ⇒ nouvelle valeur de D remplace l’ancienne valeur
D
Q
C
Architecture des Ordinateurs 39
Bistable D (synchrone / front)
D
C
D
C
QBascule
D
D
C
QBascule
D Q
Q
Q
D
Q
C
Architecture des Ordinateurs 40
Banc de registres
Construction du chemin de données (BANC DE REGISTRES)
Registre lecture numéro 1
Registre lecture numéro 2
Registre écriture
Donnée à écrire
Donnée lue 1
Donnée lue 2
Écrire
Décodeur pour chaque port de lecture ou écriture
Ensemble de registres construits avec des bistables D
(Contrôle de l’écriture)
Architecture des Ordinateurs 41
Banc de registres
Registre lecture numéro 1
Registre lecture numéro 2
R0
R1
Rn-1
Rn
….
MUX
MUX
Donnée lue 1
Donnée lue 2Numéro Registre écriture
Décodeur
n pour 1
D
D
D
C
C
C
0
1
n
écrire
Architecture des Ordinateurs 42
CHAPITRE III:
MIPS ISA
Architecture des Ordinateurs 43
Organisation d’un ordinateur
Mémoire
Entrées
Sorties
contrôle
Chemin de données
Processeur
Architecture des Ordinateurs 44
Architecture d’ensemble d’instructions• ISA: Instruction Set Architecture• Qu’est ce qu’on doit spécifier ?
–Format et codification des instructions–Emplacement des arguments résultats
• Mémoire ou autre• Combien d’arguments explicites• Quels arguments pouvant être en mémoire
–Type et taille des données–Opérations– Instructions de contrôle
• Sauts, conditions, branchements
Architecture des Ordinateurs 45
Les étapes du cycle instructionLire l’instruction (Fetch)
Décoder l’instruction (Decode)
Lire les arguments (Fetch)
Exécution (execute)
Écrire les résultats (Store)
Instruction suivante
Architecture des Ordinateurs 46
Types d’ISA4 types d’ISA : exécution de C=A+B
• Machine à pilePush A
Push B
Add
Pop C
(calculette HP) • Accumulateur, 1 seul registre (IBM 701)
Load A
Add B
Store C
• Registre-Mémoire
Load R1, A
Add R1, B
Store C, R1
(IBM 360, DEC VAX)
• Chargement-rangement (MIPS, SPARC)
Load R1, A
Load R2, B
Add R3, R1, R2
Store C, R3
Architecture des Ordinateurs 47
ISA et registres
– Les registres sont plus rapides que la mémoire
– Registre plus facile à utiliser pour compilateur (A*B)-(C*D)-(E*F)
– Registres peuvent contenir des variables• Réduction trafic mémoire• Densité du code s’améliore
– Nouvelles ISA utilisent les registres
– Pipeline => Registres chargement-rangement
•1975 → 1985 toutes les machines utilisent les registres
Architecture des Ordinateurs 48
MIPS ISA
• 230 octets mémoire
• Registres flottants: 32 * 32 bits, utilisés en paires
• Registres: 31 * 32 bits, R0=0
• HI, LO, CP (compteur ordinal)
…
R1
0
R31
CP
LO
HI
R0
Architecture des Ordinateurs 49
Types d’ISA• Depuis 1980, toutes les machines utilisent adresses au niveau de l’octet (8 bits)
– Puisqu'on peut lire un mot de 32 bits comme 4 octets en un seul coup, comment ces octets sont-ils rangés dans le mot ?
• Big-endian: l’adresse de l’octet le plus significatif est l’adresse du mot
• Little-endian: l’adresse de l’octet le moins significatif est l’adresse du mot
Numéro d’octet
Numéro d’octet
0 1 2 3
3 2 1 0
Motorola, MIPS, SPARC
Intel 8086, VAX, Alpha
– Un mot peut être placé n’importe où en mémoire?
• La plupart des instructions de chargement-rangement opèrent sur des données alignées (son adresse mémoire est multiple de sa taille en octets).
Architecture des Ordinateurs 50
Format des instructions• Taille variable, multiple d’un certain nombre de bits
• Taille fixe
• Taille hybride
(exemple, 32 pour instruction MIPS)
Types d’opérations n’a pas changé
•Transfert data : (load, store, move, input, output, push, pop)
•Arithmétique : entier (binaire, décimal), Float (add, substract, multiply, divide)
•Shift left|right, rotate left|right
•Subroutine linkage call return
•logique not, and or set clear
•Interruption trap return
•Graphique word ops
Architecture des Ordinateurs 51
Instructions 8086
cond branch 20%
compare 16%
store 12%
add 8%
and 6%
sub 5%
Mov reg-reg 4%
return 1%
call 1%
96%
Remarque: les instructions simples dominent le code
Architecture des Ordinateurs 52
Instructions MIPS
Les 32 registres de MIPS seront notés $0….$31
Instructions arithmétiques
add t0,g,h # variable temporaire t0 contient g+hadd t1,i,j # variable temporaire t1 contient i+jsub f,t0,t1 # f reçoit t0-t1 , ou (g+h) - (i+j)
Opérations équivalentes en MIPS
f = ( g + h ) - (i + j );
add $8,$17,$18 # registre $8 contient g+hadd $9,$19,$20 # registre $9 contient i+jsub $16,$8,$9 #f reçoit $8-$9 (c-à-d (g+h)-(i+j))
Remarque : les registres $8,$9 correspondent aux variables temporaires t0 et t1 de l'exemple précédent
Architecture des Ordinateurs 53
Instructions MIPS
On ne peut stocker qu'une petite quantité de données dans les registres. La mémoire d'un ordinateur contient des millions de données élémentaires, et les structures de données, telles que les tableaux, sont donc stockées en mémoire
Les opérations arithmétiques ont lieu dans les registres. Pour cela MIPS dispose d'opérations qui transfèrent les données entre la mémoire et les registres appelées instructions de transfert de données. Pour accéder à une donnée en mémoire, l'instruction doit fournir son adresse .
On a deux types d'instructions de transfert de données :
• Chargement lw : instruction qui déplace un mot de la mémoire vers un registre (LOAD) • Rangement sw : instruction qui transfert les données d'un registre vers la mémoire (STORE).
Architecture des Ordinateurs 54
Instructions MIPS (chargement)
T : un tableau de X éléments et le compilateur associe les variables g, h et i aux registres $17,$18 et $19 . Supposons aussi que le tableau débute à l'adresse Tstart.
Expression en langage C :g = h + T[i];
Assembleur MIPS : lw $8,Tstart($19) # le registre temporaire $8 reçoit T[i]add $17,$18,$8 # g = h+T[i]
MémoireProcesseur
…
10
0
1010
1
Adresse
104
Mémoire
4
12
8
…
Architecture des Ordinateurs 55
Instructions MIPS(rangement)
Les adresse des mots sont décalés de 4 dans la mémoire :
� ($19 devra contenir 4*i).
Expression en langage C :
T[i] = h + T[i];
Assembleur MIPS :
lw $8,Tsart($19) # le registre temporaire $8 reçoit T[i]
add $8,$18,$8 # le registre $8 reçoit h+T[i]
sw $8,Tstart($19) # on recopie h+T[i] dans T[i]
Architecture des Ordinateurs 56
Arithmétiques – transfert de données
Arithmétiques :
Transfert de données :
add $1, $2, $3 # $1 = $2 + $3
sub $1, $2, $3 # $1 = $2 - $3
addi $1, $2, 100 # $1= $2+100
lw $1, 100($2) # $1 = Mémoire[$2 + 100]
sw $1, 100($2) # Mémoire [$2 +100]=$1
lui $1, 100 # $1= 100*216
Architecture des Ordinateurs 57
Format d’instruction (type R)
op rs rt rd decval funct
061116212631
add $8, $17, $18 # $8 = $17 + $18
0 17 18 8 0 32
• Instruction d’addition :
• Combinaison en nombre décimaux :
… …
champ
• Représentation en nombre binaire
000000 10001 10010 01000 00000 1000006 bits 5 bits 5 bits 5 bits 5 bits 6 bits
• Instruction type R
add → 32
sub → 34
Architecture des Ordinateurs 58
Format d’instruction (type I)
lw $8, 100($18) # registre temporaire $8 reçoit la valeur # existante dans mémoire [$18+100]
• Instruction de chargement :
• Combinaison en nombre décimaux :
5 bits 5 bits 16 bits
• Instruction type I
op rs rt immediate
6 bits
35 19 8 100
lw → 35
sw → 43
Architecture des Ordinateurs 59
MIPS compare et branch (décisions)
beq reg1,reg2, E1
Aller à la séquence étiqueté par E1 si la valeur contenue dans le reg1 est égale à la valeur contenue dans reg2.
bne reg1,reg2, E1
Aller à la séquence étiqueté par E1 si la valeur contenue dans le reg1 est non égale à la valeur contenue dans reg2.
Branchement conditionnel :
Comparaison :
slt $1,$2, $3 # si $2<$3 alors $1=1 sinon $1=0
slti $1,$2, 100 # si $2<100 alors $1=1 sinon $1=0
Architecture des Ordinateurs 60
MIPS compare et branch (décisions)
Exemple en C:
if (i==j) goto E1;
f = g+h
E1: f = f = f-i;
F,g,h,i,j correspondent aux cinq registres $17 à $21
Assembleur MIPS:
beq $20,$21,E1 # aller en E1 si i==j
add $17,$18,$19 # f = g+h
E1: sub $17,$17,$20 #f = f-i
Architecture des Ordinateurs 61
MIPS compare et branch (décisions)
Exemple en C:
if (i==j) f = g+h; else f=g-h;
Assembleur MIPS:
bne $20,$21,Else # aller à Else si i≠j
add $17,$18,$19 # f = g+h
j Exit # aller à exit
Else : sub $17,$18,$19 #f = g-h
Exit :
Nouvelle instruction : j Exit
Architecture des Ordinateurs 62
Format d’instruction (type J)
26 bits
• Instruction type J
op adresse
6 bits
J 2000Exemple :
op Address destination
op rs rt rd decval funct
061116212631
op rs rt immediate
R-type
I-type
J-type
add, sub
ori, lw, sw, beq
j, jal
Différents formats d’instructions MIPS
26 bits
2 1000
6 bits
Architecture des Ordinateurs 63
Exemple
Code en C :
switch (k)
{
case 0: f=i+j; break;
case 1: f=g+h; break;
case 2: f=g-h; break;
case 3: f=i-j; break;
}
Assembleur MIPS :
mult $9,$10,$21
lw $8, Tablesaut($9)
jr $8
E0 : …
E1 : …
E2 : …
E3 : …
Exit:
f,g,h,i,j,k → $16..$21
$10 ← 4
4 mots en mémoire à partir de table saut contiennent E0,E1,E2,E3
Architecture des Ordinateurs 64
Traitement des procédures
Procédure A
Procédure B
Procédure C
Éditeur de liens
0 : procédure A
64 : procédure B
112 procédure C
Les références croisées entre les modules
• Saut de procédure.
• Retour à l’instruction qui suit l’appel.
• Passage des paramètres
• Imbrication des procédures
Architecture des Ordinateurs 65
MIPS: traitement des procédures
Instruction jal (saut avec lien)
jal AdresseProcedure
� Un lien est crée vers le site appelant la procédure. Ce lien est rangé dans $31
Adresse de retour
Le saut de retour est effectué par l’instruction : jr $31
CP: compteur de programme (registre d’adresse d’instruction) $31
Cas plus compliqué lorsque une procédure appelle une autre procédure
� Vider le registre $31 dans la mémoire
Architecture des Ordinateurs 66
MIPS: traitement des procédures
Procédure appelle une autre et …
� Structure PILE (LIFO)
Pointeur vers son sommet indiquant l’endroit de l’emplacement des registres à vider.
$29Considérons l’exemple suivant :
A:…
Jal B … jr $31
B: …
Jal C … jr $31
C: … jr $31
Architecture des Ordinateurs 67
Exemple appels de procédures
1. Après l'appel de B par AMémoire
Adresse retour de B
$31
$29
2. Juste avant que B appelle CMémoire
Adresse retour de B
$31
$29Adresse retour de B
3. Après l'appel de C par BMémoire
Adresse retour de C
$31
$29Adresse retour de B
4. Après l'appel de C par BMémoire
Adresse retour de B
$31
$29Adresse retour de B
Architecture des Ordinateurs 68
Modes d’adressage de MIPS1. Adressage par registre
op rs rt rd decval funct
061116212631
registre
2. Adressage indexé
op rs rt adresse
registre
+ Mémoire
Add $4,$2,$3
•Opérande est un registre
•Opérande se trouve à l’emplacement mémoire
lw $1,100($2)
Architecture des Ordinateurs 69
Modes d’adressage de MIPS3. Adressage immédiat
4. Adressage relatif à CP
op rs rt adresse
CP
+ Mémoire
•Opérande constante
bne $1,$2,100
5 bits 5 bits 16 bits
op rs rt immédiat
6 bits
addi $1,100
Rq. des mots séparant l ’instruction de branchement de l ’instruction cible
Architecture des Ordinateurs 70
MIPS instructions arithmétiques Instruction Exemple signification Commentaireadd add $1,$2,$3 $1 = $2 + $3 3 opérandes; exception possiblesous sub $1,$2,$3 $1 = $2 – $3 3 opérandes; exception possibleadd immediate addi $1,$2,100 $1 = $2 + 100 + constante; exception possibleadd non signé addu $1,$2,$3 $1 = $2 + $3 3 opérandes;pas d’exceptionsous non signé subu $1,$2,$3 $1 = $2 – $3 3 opérandes; pas d’exceptionadd imm. non sig addiu $1,$2,100 $1 = $2 + 100 + constante; pas d’exceptionmul mult $2,$3 Hi, Lo = $2 x $3 64-bit produit signéMul non signé multu$2,$3 Hi, Lo = $2 x $3 64-bit produit non signédiv div $2,$3 Lo = $2 ÷ $3, Lo = quotient, Hi = reste
Hi = $2 mod $3 div non signé divu $2,$3 Lo = $2 ÷ $3, reste et quotient non signé
Hi = $2 mod $3Move from Hi mfhi $1 $1 = Hi utilsé pour avoir une copie de HiMove from Lo mflo $1 $1 = Lo utilisé pour avoir une copie de Lo
Architecture des Ordinateurs 71
MIPS instructions logiques
Instruction Exemple Signification Commentaire
and and $1,$2,$3 $1 = $2 & $3 3 reg. opérandes; Logical ANDor or $1,$2,$3 $1 = $2 | $3 3 reg. opérandes; Logical ORxor xor $1,$2,$3 $1 = $2 ^ $3 3 reg. opérandes; Logical XORnor nor $1,$2,$3 $1 = ~($2 |$3) 3 reg. opérandes; Logical NORand immediat andi $1,$2,10 $1 = $2 & 10 Logical AND reg, constanteor immediat ori $1,$2,10 $1 = $2 | 10 Logical OR reg, constantexor immediat xori $1, $2,10 $1 = ~$2 &~10 Logical XOR reg, constanteshift left logical sll $1,$2,10 $1 = $2 << 10 Shift left par constanteshift right logical srl $1,$2,10 $1 = $2 >> 10 Shift right par constanteshift right arithm. sra $1,$2,10 $1 = $2 >> 10 Shift right (extention du signe) shift left logical sllv $1,$2,$3 $1 = $2 << $3 Shift left par variableshift right logical srlv $1,$2, $3 $1 = $2 >> $3 Shift right par variableshift right arithm. srav $1,$2, $3 $1 = $2 >> $3 Shift right arith. par variable
Architecture des Ordinateurs 72
MIPS instructions de transfert de données
Instruction Comment
sw $3, 500($4) enreg. D’un mot en mémoire
sh $3, 502($2) enreg. D’un demi-mot
sb $2, 41($3) enreg. D’un bit
lw $1, 30($2) chargement d’un mot
lh $1, 40($3) chargement d’un demi mot
lhu $1, 40($3) chargement d’un demi-mot non signé
lb $1, 40($3) chargement d’un bit
lbu $1, 40($3) chargement d’un bit non signé
lui $1, 40 Load Upper Immediate (16 bits shifted left par 16)
0000 … 0000
LUI R5
R5
Architecture des Ordinateurs 73
MIPS instructions de comparaison et branchement
Instruction Exemple Significationbranch on equal beq $1,$2,100 Si ($1 == $2) go to CP+4+100
Egale test; CP relative branchbranch on not eq. bne $1,$2,100 Si ($1!= $2) go to PC+4+100
Non égale test; CP relative set on less than slt $1,$2,$3 Si ($2 < $3) $1=1; else $1=0
Compare < 2’s comp. set less than imm. slti $1,$2,100 if ($2 < 100) $1=1; else $1=0
Compare < constante; 2’s comp.set less than uns. sltu $1,$2,$3 if ($2 < $3) $1=1; else $1=0
Compare<; natural nombresset l. t. imm. uns. sltiu $1,$2,100 if ($2 < 100) $1=1; else $1=0
Compare < constante; natural nombresjump j 10000 go to 10000
saut à une adressejump register jr $31 go to $31
retour de procédurejump and link jal 10000 $31 = PC + 4; go to 10000
appel de procédure
Architecture des Ordinateurs 74
CHAPITRE IV:Conception des unités arithmétiques
Architecture des Ordinateurs 75
Notions de baseApproche top-down et bottom-up
Conception UAL
Architecture des Ordinateurs 76
Arithmétique des ordinateurs• Comment les nombres négatifs sont-ils représentés ?
• Quel est le plus grand nombre qui puisse être représenté par un mot machine ?
• Que se passe-t-il si une opération génère un nombre plus grand que ce qui est possible de représenter ?
• Qu'en est-il des fractions et des nombres réels ?
�Comment le matériel fait-il réellement pour additionner, soustraire, multiplier ou diviser des nombres le plus rapidement possible ?
Le but de ce chapitre est de dévoiler ce mystère, en particulier, la représentation des nombres, les algorithmes arithmétiques…
Architecture des Ordinateurs 77
Représentation des nombres1011 en base 2, représente :
( 1 * 23) + ( 1 * 22) + ( 0 * 21) + ( 1 * 20)dix = ( 1 *8 ) + ( 1*4 ) +
( 0 * 2 ) + ( 1*1 ) dix
= 8 + 4 + 0 + 1 dix
= 11 dix
Puisqu'un mot MIPS possède 32 bits, le nombre 1101deuxsera représenté comme suit: (32 bits de large )
•Le bit du poids faible est le bit le plus à droite.
•Le bit du poids fort est le bit le plus à gauche.
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1
Architecture des Ordinateurs 78
Représentation des nombresReprésentation distinguant le positif du négatif :
•Utilisation de 1 bit de signe : ⇒ 0 va avoir une représentation positive et négative
•Complément à 2 (adopter pour les ordinateurs 32 bits)
Un nombre ayant deux représentations est plus grave qu'un déséquilibre entre les nombres positifs et les nombres négatifs.
0000 0000 0000 0000 0000 0000 0000 0000deux= 0 dix
0000 0000 0000 0000 0000 0000 0000 0001deux= 1dix
0000 0000 0000 0000 0000 0000 0000 0010deux= 2dix
..................................................................................
0111 1111 1111 1111 1111 1111 1111 1110deux= 2.147.483.646dix
0111 1111 1111 1111 1111 1111 1111 1111deux= 2.147.483.647dix
Architecture des Ordinateurs 79
Représentation des nombres0000 0000 0000 0000 0000 0000 0000 0000deux= 0 dix
0000 0000 0000 0000 0000 0000 0000 0001deux= 1dix
0000 0000 0000 0000 0000 0000 0000 0010deux= 2dix
..................................................................................
0111 1111 1111 1111 1111 1111 1111 1110deux= 2.147.483.646dix
0111 1111 1111 1111 1111 1111 1111 1111deux= 2.147.483.647dix
1000 0000 0000 0000 0000 0000 0000 0000deux= -2.147.483.648 dix
1000 0000 0000 0000 0000 0000 0000 0001deux= -2.147.483.647 dix
..................................................................................
1111 1111 1111 1111 1111 1111 1111 1110deux= -2 dix
1111 1111 1111 1111 1111 1111 1111 1111deux= -1 dix
Architecture des Ordinateurs 80
Représentation des nombres
• Cette convention s'appelle complément à deux : tous les nombres négatifs ont un 1 comme bit de poids fort.
• Le matériel n'a donc besoin de tester que ce bit pour déterminer si un nombre est positif ou non .
• Ce bit particulier est appelé souvent le bit de signe.
• Un nombre binaire de 32 bits sera alors représenté comme suit :
(x31 * -231)+ ( x30 * 2 30 ) + ................+ ( x1 * 2 1 ) + (x0 * 20)
xi : signifie : le ième bit de x
• x + (-x) = 0
• 1 seul nombre négatif -2.147.483.648 dix qui n ’a pas de nombre positif correspondant
Architecture des Ordinateurs 81
Représentation des nombresExemple:
Prendre l'opposé de 2 dix et ajouter 1
2 dix = 0000 0000 0000 0000 0000 0000 0000 0010 deux
Prendre l'opposé de ce nombre en inversant ses bits et en ajoutant 1 donne :
1111 1111 1111 1111 1111 1111 1111 1101 deux
+
1 deux
---------------------------------------------------------
= 1111 1111 1111 1111 1111 1111 1111 1110 deux
= -2 dix
Architecture des Ordinateurs 82
Représentation des nombres
• -x = x + 1
Par conséquent :
� La manière de convertir un nombre binaire représenté avec n bits en un nombre représenté avec plus de n bits: extension signée. Répliquer le bit du signe:
(16)bits : 0000 0000 0000 0010 deux
(32)bits : 0000 0000 0000 0000 0000 0000 0000 0010 deux2 dix
-2 dix
(32) bits : 1111 1111 1111 1111 1111 1111 1111 1110 deux
(16) bits : 1111 1111 1111 1110 deux
Architecture des Ordinateurs 83
Opérations logiques du MIPSOn peut faire des décalages à droite ou à gauche de tous les bits d'un mots tout en remplissant les bits vidés par des zéros.
Exemple :
le registre $16 contient 0000 0000 0000 0000 0000 0000 0000 1101deux
Une instruction de décalage de 8 bits vers la gauche du contenue du registre $16 va donner comme résultat:
0000 0000 0000 0000 0000 1101 0000 0000 deux
Il existe deux instructions pour ce genre d'opération :
•sll (shift left logical ) Décalage à gauche .
•srl (shift right logical ) Décalage à droite .
Soit l'instruction MIPS suivante
sll $10 , $16 , 8 # reg $10 = reg $16 << 8 bits
Architecture des Ordinateurs 84
Opérations logiques du MIPS
Sll et srl sont deux opérations logiques dans le format de l'instruction en MIPS et du type R , ici la valeur de décalage 8 est mise dans le champs decval , la version en langage machine sera alors :
op rs rt rd decval fonct
0 0 16 10 8 0
Architecture des Ordinateurs 85
Opérations logiques du MIPSand $8,$9,$10 # reg $8 = reg $9 ET reg$10
$9 contient :
0000 0000 0000 0000 0000 1101 0000 0000 deux
$10 contient :
0000 0000 0000 0000 0011 1100 0000 0000 deux
$8 contient 0000 0000 0000 0000 0000 1100 0000 0000 deux
or $8,$9,$10 # reg $8 = reg $9 OU reg$10
$8 contient 0000 0000 0000 0000 0011 1101 0000 0000 deux
andi $8,$9,100 # reg $8 = reg $9 ET 100
ori $8,$9,100 # reg $8 = reg $9 OU 100
Architecture des Ordinateurs 86
Processus de conception
CPU
Datapath Control
ALU Regs Shifter
NandGate
• Conception– La conception est l’assemblage
des différents composants. – Décomposition de haut en bas
d’une fonction complexe (fonctionnement) fonctions primitives.
• Commencer par les petits éléments pour aboutir à un ensemble plus complexe (du bas en haut)
La conception est un processus de création et non une simple méthode!!
Architecture des Ordinateurs 87
Conception de l’UAL
Exigences :
• add, addu, sub, subu, addi, addiu
• and, or, andi, ori
• beq, bne, slt, slti, sltu, sltiu
• addu, subu, addiu: (sans détection de débordement).
• add, sub, addi: (détection de débordement).
Architecture des Ordinateurs 88
Format des instructions arithmétiques de MIPS
Type-R :
Type-I :
31 25 20 15 5 0
op Rs Rt Rd funct
op Rs Rt Immed 16
Type op funct
ADDI 10 xx
ADDIU 11 xx
SLTI 12 xx
SLTIU 13 xx
ANDI 14 xx
ORI 15 xx
XORI 16 xx
LUI 17 xx
Type op funct
ADD 00 40
ADDU 00 41
SUB 00 42
SUBU 00 43
AND 00 44
OR 00 45
XOR 00 46
NOR 00 47
Type op funct
SLT 00 52
SLTU 00 53
Architecture des Ordinateurs 89
Conception UAL: exigencesSpécification fonctionnelleEntrées: 2 x 32-bit opérandes A, B, 4-bit pour mode.Sorties: 32-bit résultat S, 1-bit retenu, 1 bit débordementOpérations: add, addu, sub, subu, and, or, xor, nor, slt, sltU
Diagramme de bloc :
UALA B
movf
S
32 32
32
4c
Opérations signées : débordement pas de retenue !
Architecture des Ordinateurs 90
Décomposition du diagramme de bloc
A B
M
S
32 32
32
4
Ovflw
ALU0
a0 b0m
cincos0
ALU31
a31 b31m
cincos31
Réalisation de l’UAL de 32 bits en termes de 32 UAL à 1 bit
Architecture des Ordinateurs 91
Conception de UAL à 1 bit
A
Mux
Result
and
or
S-select
B
Les opérations logiques :
Architecture des Ordinateurs 92
Conception de UAL à 1 bit
B
1-bitFull
Adder
A
Cin
Cout
S
0 1 1 1
0 0 1 0+
1 (0) 0 (1) 0(1) 1 (0)
Fonction combinatoire
Cin
S
Cout
A
B
Architecture des Ordinateurs 93
Assemblage (ajout de add)
A
B
1-bitFull
Adder
CarryOut
Mu
x
CarryIn
Result
add
and
or
S-select
Architecture des Ordinateurs 94
Opérations additionnelles (sub)• A - B = A + (– B) = A + B + 1Mettre Invert à 1 et mettre CarryIn à 1
A
B1-bitFull
Adder
CarryOut
Mu
x
CarryIn
Result
add
and
or
S-selectinvert
Mu
x
Architecture des Ordinateurs 95
Exercices
• Qu’en est-il pour l’instruction slt ?• Qu’en est-il pour le branchement conditionnelle ?
UALA B
movf
S
32 32
32
4c
résultat zéro32
Architecture des Ordinateurs 96
Diagramme de bloc
• Mode et débordement
A B
M
S
32 32
32
4
Débordement
ALU0a0 b0
cinco s0ALU0a31 b31
cinco s31 ProduireS-select,Invert,c-in, …
?
Architecture des Ordinateurs 97
Débordement
• Exemples: 7 + 3 = 10 mais ...
• - 4 - 5 = - 9 mais ...
Complément de 2binaireDécimale
0 0000
1 0001
2 0010
3 0011
0000
1111
1110
1101
0
-1
-2
-3
4 0100
5 0101
6 0110
7 0111
1100
1011
1010
1001
-4
-5
-6
-7
1000-8
0 1 1 1
0 0 1 1+
1 0 1 0
1
1 1 0 0
1 0 1 1+
0 1 1 1
110
7
3
1
– 6
– 4
– 5
7
Décimale
Architecture des Ordinateurs 98
Détection de débordement• Débordement: le résultat est assez grand ou assez petit pour être représenté.
Exemple: - 8 ≤ 4-bit nombre binaire ≤ 7
• Lorsqu’on additionne deux nombres de signes différents
� Pas de débordement
0 1 1 1
0 0 1 1+
1 0 1 0
1
1 1 0 0
1 0 1 1+
0 1 1 1
110
73
1
– 6
–4–5
7
0
• Débordement se présente lorsqu’on additionne :
•2 nombres positifs et leur somme est négative.
•2 nombres négatifs et leur somme est positive.
•Prouver que si: Carry in UAL31 ≠ Carry out UAL31 on peut détecter le débordement!
Architecture des Ordinateurs 99
Logique de détection de débordement
• Débordement = CarryIn[N - 1] XOR CarryOut[N - 1]
A0
B01-bitALU
Result0
CarryIn0
CarryOut0A1
B11-bitALU
Result1
CarryIn1
CarryOut1A2
B21-bitALU
Result2
CarryIn2
A3
B31-bitALU
Result3
CarryIn3
CarryOut3
Overflow
X Y X XOR Y
0 0 00 1 11 0 11 1 0
Architecture des Ordinateurs 100
Amélioration de la performance (méthode de la retenue anticipée)
A B C-out0 0 0 “stop”0 1 C-in “propager”1 0 C-in “propager”1 1 1 “générer”
G = A and B génère une retenueP = A xor B propage une retenue
A0B0
A1B1
A2B2
A3B3
S
S
S
S
GP
GP
GP
GP
C0 = Cin
C1 = G0 + C0 • P0
C2 = G1 + G0 • PP1 + C0 • P0 • P1
C3 = G2 + G1 • PP2 + G0 • P1 • P2 + C0 • P0 • P1 • P2
G
C4 = . . .
P
Architecture des Ordinateurs 101
Amélioration de la performance (méthode de la retenue anticipée)
CLA
4-bitAdder
4-bitAdder
4-bitAdder
C1 = G0 + C0 • P0
C2 = G1 + G0 • PP1 + C0 • P0 • P1
C3 = G2 + G1 • PP2 + G0 • P1 • P2 + C0 • P0 • P1 • P2GP
G0P0
C4 = . . .
C0
Architecture des Ordinateurs 102
Multiplication et division des entiers
Architecture des Ordinateurs 103
Autres exigences: multiplication et division
Instruction Example Meaning Commentsadd add $1,$2,$3 $1 = $2 + $3 3 operandes; exception possiblesubtract sub $1,$2,$3 $1 = $2 – $3 3 operandes; exception possibleadd immediate addi $1,$2,100 $1 = $2 + 100 + constante; exception possibleadd unsigned addu $1,$2,$3 $1 = $2 + $3 3 operandes; no exceptionssubtract unsigned subu $1,$2,$3 $1 = $2 – $3 3 operandes; no exceptionsadd imm. unsign. addiu $1,$2,100 $1 = $2 + 100 + constante; no exceptionsmultiply mult $2,$3 Hi, Lo = $2 x $3 64-bit signed productmultiply unsigned multu$2,$3 Hi, Lo = $2 x $3 64-bit unsigned productdivide div $2,$3 Lo = $2 ÷ $3, Lo = quotient, Hi = remainder
Hi = $2 mod $3 divide unsigned divu $2,$3 Lo = $2 ÷ $3, Unsigned quotient & remainder
Hi = $2 mod $3Move from Hi mfhi $1 $1 = Hi Used to get copy of HiMove from Lo mflo $1 $1 = Lo Used to get copy of Lo
Architecture des Ordinateurs 104
Multiplication sans signe• Exemple de multiplication (non signée):
Multiplicande 1000
Multiplicateur 10011000
00000000
1000 Produit 01001000
• m bits x n bits = m+n bit produit (en ignorant le bit de signe)
• Multiplication binaire est simple:
– 0 => place 0 ( 0 x multiplicande)
– 1 => place une copie ( 1 x multiplicande)
• 4 versions de multiplications (matériel et algorithme):
Architecture des Ordinateurs 105
Multiplication sans signe
B0
A0A1A2A3
A0A1A2A3
A0A1A2A3
A0A1A2A3
B1
B2
B3
P0P1P2P3P4P5P6P7
0 0 0 0
• Stage i accumule A * 2 i if Bi == 1• Pour multiplier 32 bits pb. de hardware?
Architecture des Ordinateurs 106
Multiplication sans signe
• À chaque stage shift A left ( x 2).• Utiliser le bit suivant de B pour déterminer si la
somme sera réalisée• A chaque stage on accumule 2n bits produit partiel.
B0A0A1A2A3
A0A1A2A3
A0A1A2A3
A0A1A2A3
B1
B2
B3
P0P1P2P3P4P5P6P7
0 0 0
Architecture des Ordinateurs 107
Chemin de données multiplication (Version 1)
• Registre Multiplicande (64-bit), UAL 64-bit, registre produit (64-bit), registre multiplicateur (32-bit).
Produit
Multiplicateur
Multiplicande
64-bit UAL
Décalage gauche
Décalage droite
EcritureContrôle
32 bits
64 bits
64 bits
Multiplicateur = chemin de données + contrôle
Architecture des Ordinateurs 108
Algorithme de multiplication (Version 1)
3. Décaler le registre Multiplicateur de 1 bit à droite.
Fin
Oui
2. Décaler le registre Multiplicande de 1 bit à gauche.
Non
1. TesterMultiplicateur0
= 0= 1
1a. Additionner multiplicande au produit & placer le résultat dans le registre Produit
début
• Produit Multiplicateur Multiplicande 0000 0000 0011 0000 0010
• 0000 0010 0001 0000 0100• 0000 0110 0000 0000 1000• 0000 0110 0000 0001 0000• 0000 0110 0000 0010 0000
21
34 Répétition
32?
Architecture des Ordinateurs 109
Observations sur la (Version 1)
• La moitié (1/2) des bits du multiplicande était toujours à 0=> 64-bit UAL (add) semble beaucoup (lente et peu
économique)• 0’s sont insérés à gauche du multiplicande lors du
décalage => une fois crées, les bits de poids faible du produit ne peuvent jamais changer.
• Que se passe t-il si on décale le produit à droite?
Maintenir le multiplicande fixe et faire le décalage du produit!
Architecture des Ordinateurs 110
Hardware multiplication (Version 2)
• Registre Multiplicande (32-bit), UAL (32 -bit), registre Produit 64-bit, registre Multiplicateur 32-bit.
Product
Multiplier
Multiplicande
32-bit UAL
Décalage droite
EcritureContrôle
32 bits
32 bits
64 bits
Décalage droite
Architecture des Ordinateurs 111
Comment ça marche?
B0
B1
B2
B3
P0P1P2P3P4P5P6P7
0 0 0 0
A0A1A2A3
A0A1A2A3
A0A1A2A3
A0A1A2A3
Architecture des Ordinateurs 112
Algorithme de multiplication (Version 2)
3. Shift le registre multiplicateur à droite de 1 bit.
Fin
Oui
2. Décaler le registre produit à droite de 1 bit.
Non
1. TesterMultiplicateur0
= 0= 1
1a. Additionner multiplicande à la moitié gauche du produit & place le résultat dans la moitié gauche du registre produit
début
0000 0000 0011 00101: 0010 0000 0011 00102: 0001 0000 0011 00103: 0001 0000 0001 00101: 0011 0000 0001 00102: 0001 1000 0001 00103: 0001 1000 0000 00101: 0001 1000 0000 00102: 0000 1100 0000 00103: 0000 1100 0000 00101: 0000 1100 0000 00102: 0000 0110 0000 00103: 0000 0110 0000 0010
0000 0110 0000 0010
Product Multiplier Multiplicand
1
2
3
4
Répétition32?
Architecture des Ordinateurs 113
Observations sur la (Version 2) et hardware de la (Version 3)
• Seule la partie gauche du produit est modifiée. (sur 32 bits)
� Combiner le registre produit et le registre multiplicateur (gagner de l’espace)
• Registre multiplicande (32-bits), UAL 32-bits, Registre produit (64-bits) dont 32 registres multiplicateurs
Produit (Multiplicateur)
Multiplicande
32-bit UAL
EcritureContrôle
32 bits
64 bits
Décalage droite
Architecture des Ordinateurs 114
Algorithme de multiplication (Version 3)
Fin
Oui
2. Décaler le registre produit à droite de 1 bit.
Non
1. TesterProduit0
= 0= 1
1a. Additionner multiplicande à la moitié gauche du produit & Placer le résultat dans la moitié gauche du registre produit
Répétition32?
début
Multiplicande Produit0010 0000 00110010 0010 0011
0001 00010010 0011 0001
0001 10000010 0000 11000010 0000 0110
1
234
Architecture des Ordinateurs 115
Observations sur la version 3 de la multiplication
• 2 étapes pour chaque calcul d'un bit (multiplicateur et produit combinés)
• Hi/Lo sont les deux demies parties du registre produit gauche et droite
• MultU, multiplication non signée
• Comment réaliser la multiplication d’une manière plus vite?
• Comment on traite la multiplication signée?– Multiplication positive jusqu’au 31 bits puis appliquer le bit de
signe (appliquer la définition du complément à 2)– Algorithme de Booth est une manière élégante pour la
multiplication des nombres signés en utilisant le même matériel utilisé en version 3; de plus on gagne dans certains cycles.
Architecture des Ordinateurs 116
• Exemple 2 x 6 = 0010 x 0110:0010
x 0110+ 0000 décalage (0 multiplicateur)+ 0010 addition (1 multiplicateur)+ 0010 addition (1 multiplicateur)+ 0000 décalage (0 multiplicateur)
…00001100
• UAL addition ou soustraction peut avoir le même résultat mais de manière différente:
• 6 = – 2 + 8 0110 = – 00010 + 01000 = 11110 + 01000
• Par exemple 0010
x 0 110
0000 décalage(0 multiplicateur)
– 0010 sub(le premier 1 du multiplicateur)
0000 décalage (les 1 de milieu)
+ 0010 addition (juste après la liste des 1) 00001100
Motivation pour l’algorithme de Booth
Architecture des Ordinateurs 117
Algorithme de boothBit courant Bit à droite Explication
Example Op1 0 début d ’exe. des 1s
0001111000 sub
1 1 milieu d ’exe. des 1s0001111000 rien
0 1 fin d ’exe. des 1s0001111000 add
0 0 milieu d ’exe. des 0s0001111000 rien
temps d’exécution est meilleur (décalage est plus rapide que l ’addition)
• Remplacer la chaîne de 1s dans le multiplicateur par une soustraction lorsqu’on identifie le premier 1et une addition pour le bit juste après le dernier 1 de la chaîne.
Architecture des Ordinateurs 118
Exemple (2 x 7), algorithme de Booth
1a. P = P - m 1110 + 11101110 0111 0
dec. P (ext. signée)
1b. 0010 1111 0011 1 11 -> nop, dec.
2. 0010 1111 1001 111 -> nop, dec.
3. 0010 1111 1100 101 -> add
4a. 0010 + 0010
0001 1100 1 dec.
4b. 0010 0000 1110 0 fin
Opération Multiplicande Produit suivant?
0. Val. initiale 0010 0000 0111 0 10 -> sub
Architecture des Ordinateurs 119
Exemple (2 x -3), algorithme de BoothOpération Multiplicande Produit suivant?
0. Val. initiale 0010 0000 1101 0 10 -> sub
1a. P = P - m 1110 + 11101110 1101
0 dec. P (ext. signée)
1b. 0010 1111 0110 1 01 -> add + 0010
2a. 0001 0110 1 dec. P
2b. 0010 0000 1011 0 10 -> sub + 1110
3a. 0010 1110 1011 0 dec.
3b. 0010 1111 0101 1 11 -> nop
4a 1111 0101 1 dec.
4b. 0010 1111 1010 1 Fin
Architecture des Ordinateurs 120
Preuve de l’algorithme de Booth (représentation complément de 2)
Soit a: multiplicateur et b: multiplicande, ai: le ièmebit de a.
ai ai-1 opération
0 0 Ne rien faire0 1 Ajout de b1 0 Soustraire b1 1 Ne rien faire
ai-1-ai
0
0
-11
Un décalage à gauche du multiplicande peut être considéré comme une multiplication par une puissance de 2
)).2(....)2()2((2)(2)(...2)()()(
00
3030
3131
313130
303029
11001
aaabbaabaabaabaaBoothselonba
+++−×=××−+××−++××−+×−=× −
Représentation en complément à 2
Architecture des Ordinateurs 121
Observations sur l’algorithme de Booth
•Problème pour des 1 isolés (addition suivie d’une soustraction)
•Résolution du problème grâce là la factorisation judicieuse de la représentation en complément à 2
Exercice
Algorithme de Booth , réduire le nombre d’op. éviter les op. en présence de 0 et 1. Modifier l’algorithme de Booth pour traiter 3 bits à la fois et calculer le multiplicande 2 bits par 2 bits.
Architecture des Ordinateurs 122
DécalageDeux cas:
logique-- valeur ajoutée est toujours 0
arithmétique-- extension du signé (shift droite)
msb lsb"0" "0"
msb lsb "0"8-bit décalage à droite
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
S2 S1 S0A0A1A2A3A4A5A6A7
R0R1R2R3R4R5R6R7
Architecture des Ordinateurs 123
Division1001 Quotient
Diviseur 1000 1001010 Dividende–1000
101011010
–100010 reste (ou modulo r ésultat)
Le grand nombre à soustraire, création d ’un bit à chaque étapebinaire => 1 * diviseur ou 0 * diviseur
Dividende = Quotient x Diviseur + Reste
3 versions de divisions, comme pour la multiplication (plus simple ou moins coûteux)
Architecture des Ordinateurs 124
Division version 1 du matériel• registre diviseur 64-bits, UAL 64 bits,
registre reste 64 bits, registre quotient 32 bits.
Reste
Quotient
diviseur
UAL 64-bit
Décalage à droite
Décalage à gauche
Ecriture Contrôle
32 bits
64 bits
64 bits
Architecture des Ordinateurs 125
Algorithme de division (version 1)
2b. Restaurer la valeur en additionnant le registre diviseur au reste et en plaçant la somme dans le registre reste. De plus, décalagedu registre quotient en insérant un 0.
Tester reste
< 0 ≥ 0
1. Soustraire le registre diviseur du register reste etplacer le résultat dans le registrer reste .
2a. Décalage du registre quotientà gauche en insérant un 1
3.décalage de 1 bit vers la droite du registre diviseur .
Fin
Oui
début: Placer le dividende dans le reste
Répétitionn+1?
Non
Architecture des Ordinateurs 126
Exemple de division (7 / 2)
Reste Quotient Diviseur0000 0111 0000 0010 0000
1: 1110 0111 0000 0010 00002: 0000 0111 0000 0010 00003: 0000 0111 0000 0001 00001: 1111 0111 0000 0001 00002: 0000 0111 0000 0001 00003: 0000 0111 0000 0000 10001: 1111 1111 0000 0000 10002: 0000 0111 0000 0000 10003: 0000 0111 0000 0000 01001: 0000 0001 0000 0000 0100 2: 0000 0011 0001 0000 0100 3: 0000 0011 0001 0000 0010 1: 0000 0001 0001 0000 0010 2: 0000 0001 0011 0000 0010 3: 0000 0001 0011 0000 0001
réponseQuotient = 3Reste = 1
1
2
3
4
5
Architecture des Ordinateurs 127
Observations sur la version 1 de la division
• 1/2 des bits du diviseur sont toujours à 0=> 1/2 des 64-bits de l'addition=> 1/2 du diviseur
• au lieu de décaler le diviseur à droite, on décale le reste à gauche?
• La première étape, ne peut pas produire un 1 dans le bit quotient (sinon ça serais plus grand) => décalage avant la soustraction, gagner une itération.
Architecture des Ordinateurs 128
Division version 2 du matériel
Reste
Quotient
Diviseur
32-bit ALU
Décalage à gauche
EcrireContrôle
32 bits
32 bits
64 bits
Décalage à gauche
• registre diviseur 32-bits, UAL 32 bit, registre reste 64 bits, registre quotient 32 bits.
Architecture des Ordinateurs 129
Algorithme de division (version 2)
2b. Restaurer la valeur ancienne en additionnant le registre diviseur à la partie gauche du reste et en plaçant la somme dans la partie gauche du registrereste. De plus, décalage du registre quotient en insérant un 0.
Test reste
< 0 ≥ 0
1. Sub registre diviseur de la partie gauche du registre reste et placer le résultat dans la partiegauche du registre reste
2a. Décalage du registre quotientà gauche en insérant un 1
Fin
Oui
début: Placer le dividende dans le registre reste
Répétitionn?
Non
3.décalage de 1 bit vers la gauche du registre reste
Architecture des Ordinateurs 130
Exemple de division (7 / 2)
réponseQuotient = 3Reste = 1
1
2
3
4
Reste Quotient Diviseur
0000 0111 0000 00101: 0000 1110 0000 0010 2: 1111 1110 0000 0010 3: 0000 1110 0000 0010 1: 0001 1100 0000 0010 2: 1111 1100 0000 0010 3: 0001 1100 0000 0010 1: 0011 1000 0000 0010 2: 0001 1000 0000 0010 3: 0001 1000 0001 0010 1: 0011 0000 0001 0010 2: 0001 0000 0000 0010 3: 0001 0000 0011 0010
Architecture des Ordinateurs 131
Division version 3 du matériel
• registre diviseur 32-bits, UAL 32 bits, registre reste 64 bits, 0 registre quotient.
reste (Quotient)
Diviseur
32-bits UAL
Contrôle
32 bits
64 bits
“HI” “LO”
Architecture des Ordinateurs 132
Algorithme de division (version 3)
3b. Restaurer la valeur originale en additionnant le registre diviseur à la moitié gauche du registre reste , et placer la somme dans la moitié gauche du registre reste. Décaler le registre reste en insérant un 0.
Tester Reste
< 0≥ 0
2. Soustraire le diviseur de la moitié gauche du registre reste et placer le résultat dans la moitié gauche du registre reste.
3a. Décalage du registre reste à gauche en insérant un 1 dans le nouveau bit
1.décalage du registre reste à gauche de 1 bit.
Fin. Décalage le reste à droite de 1 bit.
Oui
Répétitionn?
Non
Début: placer le dividende dans reste
Architecture des Ordinateurs 133
Exemple de division (7 / 2)
réponseQuotient = 3Reste = 1
1
2
3
4
Reste Diviseur0000 0111 00100000 1110 0010
1: 1111 1110 0010 2: 0001 1100 0010
1: 1111 1100 0010 2: 0011 1000 0010 1: 0001 1000 0010 2: 0011 0001 0010
1: 0001 0001 0010 2: 0010 0011 0010
3: 0001 0011 0010
Architecture des Ordinateurs 134
Observations sur la version 3 de la division• Même matériel que la multiplication: UAL pour
additionner ou soustraire, un registre 64 bits pour décaler à droite ou à gauche.
• Les registres Hi et Lo de MIPS sont combinés pour être utilisés comme registre 64-bits à la division et à la multiplication.
• Division signée: faire la division positive, modifier le signe du quotient ou du reste si nécessaire.– Note: le dividende et le reste doivent avoir le
même signe.– Quotient – si signe diviseur <> signe
dividende
– Remarque: • –7 ÷ 2 = –3, reste = –1• –7 ÷ -2 = 4, reste = -1
Architecture des Ordinateurs 135
Arithmétique de flottants
Architecture des Ordinateurs 136
Le flottant
• Qu'est ce qu'on peut représenter avec N bits?• Non-signée 0 à 2N - 1• Complément à 2 - 2N-1 à 2N-1 - 1
• Pour les grands nombres?– Nombres assez grands ?
9,349,398,989,787,762,244,859,087,678– Nombres assez petits ?
0.0000000000000000000000045691– Rationnel 2/3
Architecture des Ordinateurs 137
Le flottant
6.02 x 1023
exposant
(base)Mantisse
Point décimal
IEEE: ± 1.M x 2 e - 127
–Arithmétique (+, -, *, / )–Représentation, Norme et format–Précision–Exceptions (ex., division par zero, overflow,
underflow)–Erreurs–Propriétés (négation, inversion, if A ≠ B then
A - B ≠ 0 )
Architecture des Ordinateurs 138
Le flottantReprésentation des nombres en virgule flottante selon la norme IEEE 754
Précision simple :1 8 23
signe
Exposant: excès 127
Exposant actuele = E - 127
S E M
N = (-1) 2 (1. M)S E-127
0 < E < 255
0 = 0 000000000 . . . 0 -1.5 = 1 0111111110 . . . 0
Les nombres qu'on peut représenter:
2-126
(1.0) to 2127
(2 - 2 -23 )
Approximativement:
1.8 x 10-38
to 3.40 x 10 38
Représentation simplifiée (tri des flottants)
(-1)s×(20+(m1×2-1 +(m2×2-2)+...m52×2-23) ×2E-127
Architecture des Ordinateurs 139
Algorithme d’addition (Flottant)
3. Normalisation : décaler à droite; décalage gauche
Débordement sous débordement
?
1. Comparer les exposants des deux nombres. Décaler la mantisse la plus petite à droite jusqu’à ce que son exposant corresponde à l ’exposant le plus grand.
4. Arrondir la mantisse
Fin
début:
Exception
2. Addition / soustraction des mantisses
Normaliser?
NonOui
Non
Oui
Architecture des Ordinateurs 140
Exemple d’addition (Flottant)
0.5 - 0.4375 = ???????
1.0 × 2-1 - 1.11 × 2-2
1. - 1.11 × 2-2 → -0.111 2-1
2. 1.0 - 0.111→ 0.001
3.
Donc 0.001 × 2-1
1.0 × 2-4
Pas de débordement ou sous débordement de l ’exposant
-126<=4<=127
4. Arrondit : OK
Architecture des Ordinateurs 141
Exemple d’addition (Flottant)
1. 1.0 2127 + 1.0 2127
2. 1.0 +1.0 → 10.0
3.
Donc 10.0 × 2127
1.0 × 2128
Débordement de l ’exposant
1. 1.1 2-126 - 1.0 2-126
2. 1.1 - 1.0 → 0.1
3.
Donc 0.1 × 2-126
1.0 × 2-127
Sous débordement de l ’exposant
Architecture des Ordinateurs 142
Matériel pour l’addition des flottants
• UAL pour le calcul de l ’exposant le plus petit.
• UAL pour ajout des mantisses et détermination du signe.
• Matériel pour normalisation (décalage, incrémentation, décrémentation)
• Matériel pour le traitement de l’arrondissement
Architecture des Ordinateurs 143
ISA MIPS
• 32 registres flottants; utilisés par paire pour un traitement double flottant.
• Add.s $f2,$f4,$f6 # $f2=$f4+$f6• sub.s, mult.s, • add.d $f2,$f4, $f6 #($f3,$f5,$f7 sont
utilisés pour double flottant)• sub.d• mult.d
Architecture des Ordinateurs 144
Multiplication1. Addition exposant (R+127)
R1+R2=E1+E2+2*127 donc R1+R2-127=E1+E2+127
2. Multiplication des mantisses (mantisse 0!)
3. Normalisation (sous deb. Ou deb. )
4. Arrondi
5. Signe
Exemple: 5.5 * 0.5
5.5 → 101.1 → 1.011 * 22
0.5 →0.1 → 1.0 * 2-1
Résultat : 1.011* 21 = 2.75
Architecture des Ordinateurs 145
CHAPITRE V:Conception de microprocesseur monocycle
Architecture des Ordinateurs 146
Chemin de données pour monocycle
Architecture des Ordinateurs 147
Unité de lecture de l’instruction• Les opérations en RTL (RTL: langage
transfert registres)– mem[PC]
• Cas séquentiel : PC <- PC + 4 • Branch ou Jump: PC <- “autre adresse”
32
InstructionAddresse
Mémoire Instructions
PCClk
Calcul add.Suiv.
Architecture des Ordinateurs 148
Add & SubR[rd] <- R[rs] op R[rt] Exemple: addU rd, rs, rt
– Ra, Rb : champs de l ’instruction (rs, rt, rd) – ALUctr, RegWr: logique de contrôle après décodage
32
Result
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32x32-bitRegistres
Rs RtRd
ALU
op rs rt rd shamt funct
061116212631
6 bits 6 bits5 bits5 bits5 bits5 bits
Architecture des Ordinateurs 149
Temps op. registre-registre
32Result
ALUctr
Clk
busW
RegWr
3232
busA
32busB
5 5 5
Rw Ra Rb32x32-bitRegistres
Rs RtRd
ALU
Clk
PC
Rs, Rt, Rd,Op, Func
Temps Propagation PC
ALUctr
Accès mémoire pour Instruction
Valeur Anc. Nouv. Valeur
RegWr Valeur Anc. Nouv. Valeur
Délai Logique de Controle
busA, BAccés Registres
Valeur Anc. Nouv. Valeur
busWDélai ALU
Valeur Anc. Nouv. Valeur
Valeur Anc. Nouv. Valeur
Nouv. ValeurValeur Anc.
Ecriture ce fait ici
Architecture des Ordinateurs 150
Opération logique avec val. immédiateR[rt] <- R[rs] op ZeroExt[imm16] ]
32
Result
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32x32-bitRegistres
Rs
RtRdRegDst
ZeroE
xt
Mux
Mux
3216imm16
ALUSrc
ALU
op rs rt immédiate
016212631
6 bits 16 bits5 bits5 bits rd?
immédiate
016 1531
16 bits16 bits
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Architecture des Ordinateurs 151
Opération de chargementR[rt] <- Mem[R[rs] + SignExt[imm16]] Exemple: lw rt, rs, imm16
op rs rt immédiate
016212631
6 bits 16 bits5 bits5 bits rd?
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
5 5 5
Rw Ra Rb
32x32-bitRegistres
Rs
RtRd
RegDst
Extender
Mux
Mux
3216
imm16
ALUSrc
ExtOp
Clk
Data InWrEn
32
Adr
MémoireDonnées
32
ALU
MemWr Mux
W_Src
Architecture des Ordinateurs 152
Opération de rangementMem[ R[rs] + SignExt[imm16]<- R[rt] ] exemple: sw rt, rs, imm16
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
55 5
Rw Ra Rb
Registres32x32-bits
Rs
Rt
Rt
Rd
RegDst
Extender
Mux
Mux
3216imm16
ALUSrcExtOp
Clk
Data InWrEn
32
Adr
MémoireDonnées
MemWr
ALU
op rs rt immédiate
016212631
6 bits 16 bits5 bits5 bits
32
Mux
W_Src
Architecture des Ordinateurs 153
Saut conditionnel (Branch)
• beq rs, rt, imm16
– mem[PC] Chercher instruction de mémoire
– Cond= <- R[rs] == R[rt] Calculer la condition du saut
– if (Cond=) Calculer adresse de la prochaine inst.• PC <- PC + 4 + ( SignExt(imm16) x 4 )
– else• PC <- PC + 4
op rs rt immédiate
016212631
6 bits 16 bits5 bits5 bits
Architecture des Ordinateurs 154
Saut conditionnel (branch)beq rs, rt, imm16 Chemin données génère condition (Cond=)
op rs rt immédiate
016212631
6 bits 16 bits5 bits5 bits
32
imm16
PC
Clk
00
Adder
Mux
Adder
4nPC_sel
Clk
busW
RegWr
32
busA
32
busB
5 5 5
Rw Ra Rb
Registres32x32-bits
Rs Rt
?
Cond=
PC
Ext
Adresse Inst.
Architecture des Ordinateurs 155
Assemblage: chem. données. monocycleim
m1
6
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
55 5
Rw Ra Rb
Registres32x32-bits
Rs
Rt
Rt
RdRegDst
Extender
Mux
3216imm16
ALUSrcExtOp
Mux
MemtoReg
Clk
Data InWrEn32 Adr
MémoireDonnées
MemWrA
LUEqual
Instruction<31:0>
0
1
0
1
01
<2
1:2
5>
<1
6:2
0>
<11
:15
>
<0
:15
>
Imm16RdRtRs
=
Adder
Adder
PC
Clk
00Mux
4
nPC_sel
PC
Ext
Adr
MémoireInst.
Architecture des Ordinateurs 156
Vue simplifiée du chemin critique • Banc de Registres et Mémoire Idéalisée:
– Le CLK important SEULEMENT durant écriture– Durant lecture, comportement comme circuits combinatoires:
• Adresse valide => Sortie valide après “temps accès”
Chemin critique (LOAD) = Temps Propagation PC +Temps accès Mémoire Instruction +Temps accès Banc Registres +Temps ALU pour 32-bit Addition +Temps accès Mémoire Données +Temps établissement banc registres +Temps de Désalignement
Clk
5
Rw Ra Rb
RdA
LU
Clk
Data In
Adresse DonnéesMémoireDonnéesIdéalisée
Instruction
AdresseInstruction
MémoireInstructionIdéalisée
Clk
PC
5Rs
5Rt
16Imm
32
323232
A
B
Pro
ch. A
ddr.
Registres32x32-bits
Architecture des Ordinateurs 157
Chemin de données et RTL -> contrôle
ALUctrRegDst ALUSrcExtOp MemtoRegMemWr Cond=
Instruction<31:0>
<2
1:2
5>
<1
6:2
0>
<11
:15
>
<0
:15
>
Imm16RdRsRt
nPC_sel
Adr
MémoireInst.
Chemin Données
Contrôle
Op
<2
1:2
5>
Fun
RegWr
Architecture des Ordinateurs 158
MIPS chemin données
Architecture des Ordinateurs 159
Unité de contrôle pour monocycle
Architecture des Ordinateurs 160
Signification des signaux de contrôle
Adr
MémoireInst.
nPC_sel: 0 => PC <– PC + 4; 1=>PC<–PC+4+SignExt(Im16) || 00
Adder
Adder
PC
Clk
00Mux
4
nPC_sel
PC
Extim
m1
6
Architecture des Ordinateurs 161
Signification des signaux de contrôleExtOp: “zero”, “signe”
ALUsrc: 0 => regB; 1 => immed
ALUctr: “add”, “sub”, “or”
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
55 5
Rw Ra Rb
32x32-bitRegistres
Rs
Rt
Rt
RdRegDst
Extender
Mux
3216imm16
ALUSrcExtOp
Mux
MemtoReg
Clk
Data InWrEn32 Adr
MémoireDonnées
MemWr
ALU
Cond=
0
1
0
1
01
° MemWr: Ecrire mémoire donn.
° MemtoReg:1 => Mem
° RegDst: 0 => “rt”; 1 => “rd”
° RegWr: ecrire registre dest
=
Architecture des Ordinateurs 162
Signaux de contrôleinst Register Transfer
ADD R[rd] <– R[rs] + R[rt]; PC <– PC + 4
ALUsrc = RegB, ALUctr = “add”, RegDst = rd, RegWr, nPC_sel = “+4”
SUB R[rd] <– R[rs] – R[rt]; PC <– PC + 4
ALUsrc = RegB, ALUctr = “sub”, RegDst = rd, RegWr, nPC_sel = “+4”
ORi R[rt] <– R[rs] + zero_ext(Imm16); PC <– PC + 4
ALUsrc = Im, Extop = “Z”, ALUctr = “or”, RegDst = r t, RegWr, nPC_sel = “+4”
LOAD R[rt] <– MEM[ R[rs] + sign_ext(Imm16)]; PC <– PC + 4
ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemtoReg, RegDst = rt, RegWr, nPC_sel = “+4”
STORE MEM[ R[rs] + sign_ext(Imm16)] <– R[rs]; PC <– PC + 4
ALUsrc = Im, Extop = “Sn”, ALUctr = “add”, MemWr, n PC_sel = “+4”
BEQ if ( R[rs] == R[rt] ) then PC <– PC + sign_ext(Imm16)] || 00 else PC <– PC + 4
nPC_sel = Cond=, ALUctr = “sub”
Architecture des Ordinateurs 163
Logique pour chaque signal de contrôle• nPC_sel <= if (OP == BEQ) then Cond= else 0
• ALUsrc <= if (OP == “000000”) then “regB” else “immed”
• ALUctr <= if (OP == “000000”) then functelseif (OP == ORi) then “OR” elseif (OP == BEQ) then “sub” else “add”
• ExtOp <= if (OP == ORi) then “zero” else “signe”
• MemWr <= (OP == Store)
• MemtoReg <= (OP == Load)
• RegWr: <= if ((OP == Store) || (OP == BEQ)) then 0 else 1
• RegDst: <= if ((OP == Load) || (OP == ORi)) then 0 else 1
Architecture des Ordinateurs 164
Conception unité de contrôle pour monocycle
Table des Signaux de Contrôle :
add sub ori lw sw beq jump
RegDst
ALUSrc
MemtoReg
RegWr
MemWr
nPCsel
Jump
ExtOp
ALUctr<2:0>
1
0
0
1
0
0
0
x
Add
1
0
0
1
0
0
0
x
Sub
0
1
0
1
0
0
0
0
Or
0
1
1
1
0
0
0
1
Add
x
1
x
0
1
0
0
1
Add
x
0
x
0
0
1
0
x
Sub
x
x
x
0
0
0
1
x
xxx
op Adresse destination
op rs rt rd decval funct
061116212631
op rs rt immediate
R-type
I-type
J-type
add, sub
ori, lw, sw, beq
jump
func
op 00 0000 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
10 0000Mips ISA 10 0010 xxxxxxx
Architecture des Ordinateurs 165
Décodage Local
R-type ori lw sw beq jump
RegDst
ALUSrc
MemtoReg
RegWr
MemWr
Branch
nPCsel
ExtOp
ALUop<N:0>
1
0
0
1
0
0
0
x
“R-type”
0
1
0
1
0
0
0
0
Or
0
1
1
1
0
0
0
1
Add
x
1
x
0
1
0
0
1
Add
x
0
x
0
0
1
0
x
Sub
x
x
x
0
0
0
1
x
xxx
op 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
ContrôlePrincip.
op
6
ALUContrôle(Local)
func
N
6ALUop
ALUctr
3
ALU
Architecture des Ordinateurs 166
Codification de ALUop
• ALUop demande 2 bits pour représentation (4 codes):– (1) “R-type” instructions (reste codifié par func)– “I-type” instructions :
• (2) Or, (3) Add, (4) Sub• Plus de bits pour le MIPS ISA complet (3 bits)
– (1) “R-type” instructions– “I-type” instructions :
• (2) Or, (3) Add, (4) Subtract, et (5) And (Example: andi)
ContrôlePrincip.
op
6
ALUContrôle(Local)
func
N
6ALUop
ALUctr
3
R-type ori lw sw beq jump
ALUop (Symbolique) “R-type” Or Add Add Sub xxx
ALUop<2:0> 1 00 0 10 0 00 0 00 0 01 xxx
Architecture des Ordinateurs 167
Décodage du champ “func”
R-type ori lw sw beq jump
ALUop (Symbol.) “R-type” Or Add Add Sub xxx
ALUop<2:0> 1 00 0 10 0 00 0 00 0 01 xxx
ContrôlePrincip.
op
6
ALUContrôle(Local)
func
N
6ALUop
ALUctr
3
op rs rt rd decval funct
061116212631
R-type
funct<5:0> Op. Instruction
10 0000
10 0010
10 0100
10 0101
10 1010
addition
soustraction
and
or
slt
ALUctr<2:0> Operation ALU
000
001
010
110
111
Add
Sub
And
Or
SLT
D ’après conception de L ’ALU:
ALUctr
ALU
Architecture des Ordinateurs 168
Table de Vérité de ALUctr
R-type ori lw sw beqALUop(Symbolique) “R-type” Or Add Add Sub
ALUop<2:0> 1 00 0 10 0 00 0 00 0 01
ALUop func
bit<2> bit<1> bit<0> bit<2> bit<1> bit<0>bit<3>
0 0 0 x x x x
ALUctrOperationALU
Add 0 1 0
bit<2> bit<1> bit<0>
0 x 1 x x x x Sub 1 1 0
0 1 x x x x x Or 0 0 1
1 x x 0 0 0 0 Add 0 1 0
1 x x 0 0 1 0 Sub 1 1 0
1 x x 0 1 0 0 And 0 0 0
1 x x 0 1 0 1 Or 0 0 1
1 x x 1 0 1 0 SLT 1 1 1
funct<3:0> Op. Instruction
0000
0010
0100
0101
1010
addition
soustraction
and
or
slt
Architecture des Ordinateurs 169
Equation logique pour ALUctr<2>
ALUop func
bit<2> bit<1> bit<0> bit<2> bit<1> bit<0>bit<3> ALUctr<2>
0 x 1 x x x x 1
1 x x 0 0 1 0 1
1 x x 1 0 1 0 1
• ALUctr<2> = !ALUop<2> & ALUop<0> +ALUop<2> & !func<2> & func<1> & !func<0>
func<3> pas important
Architecture des Ordinateurs 170
Equation logique pour ALUctr<1>
ALUop func
bit<2> bit<1> bit<0> bit<2> bit<1> bit<0>bit<3>
0 0 0 x x x x 1
ALUctr<1>
0 x 1 x x x x 1
1 x x 0 0 0 0 1
1 x x 0 0 1 0 1
1 x x 1 0 1 0 1
• ALUctr<1> = !ALUop<2> & !ALUop<0> +ALUop<2> & !func<2> & !func<0>
Architecture des Ordinateurs 171
Equation logique pour ALUctr<0>
ALUop func
bit<2> bit<1> bit<0> bit<2> bit<1> bit<0>bit<3> ALUctr<0>
0 1 x x x x x 1
1 x x 0 1 0 1 1
1 x x 1 0 1 0 1
• ALUctr<0> = !ALUop<2> & ALUop<0> + ALUop<2> & !func<3> & func<2> & !func<1> & func<0>+ ALUop<2> & func<3> & !func<2> & func<1> & !func<0>
Architecture des Ordinateurs 172
Bloc de contrôle de l ’ALU
ALUContrôle(Local)
func
3
6ALUop
ALUctr
3
• ALUctr<2> = !ALUop<2> & ALUop<0> +ALUop<2> & !func<2> & func<1> & !func<0>
• ALUctr<1> = !ALUop<2> & !ALUop<0> +ALUop<2> & !func<2> & !func<0>
• ALUctr<0> = !ALUop<2> & ALUop<0> + ALUop<2> & !func<3> & func<2> & !func<1> & func<0>+ ALUop<2> & func<3> & !func<2> & func<1> & !func<0>
Architecture des Ordinateurs 173
Table de vérité pour le contrôle principal
R-type ori lw sw beq jump
RegDst
ALUSrc
MemtoReg
RegWr
MemWr
nPCsel
Jump
ExtOp
ALUop (Symbolic)
1
0
0
1
0
0
0
x
“R-type”
0
1
0
1
0
0
0
0
Or
0
1
1
1
0
0
0
1
Add
x
1
x
0
1
0
0
1
Add
x
0
x
0
0
1
0
x
Sub
x
x
x
0
0
0
1
x
xxx
op 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
ALUop <2> 1 0 0 0 0 x
ALUop <1> 0 1 0 0 0 x
ALUop <0> 0 0 0 0 1 x
ContrôlePrincipal
op
6
ContrôleALU
(Local)
func
3
6
ALUop
ALUctr
3
RegDst
ALUSrc
:
Architecture des Ordinateurs 174
Table de vérité pour RegWr
R-type ori lw sw beq jump
RegWr 1 1 1 0 0 0
op 00 0000 00 1101 10 0011 10 1011 00 0100 00 0010
op<0>
op<5>. .op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
R-type ori lw sw beq jump
RegWr
• RegWr = R-type + ori + lw= !op<5> & !op<4> & !op<3> & !op<2> & !op<1> & !op<0> (R-type)
+ !op<5> & !op<4> & op<3> & op<2> & !op<1> & op<0> (ori)+ op<5> & !op<4> & !op<3> & !op<2> & op<1> & op<0> (lw)
Architecture des Ordinateurs 175
Implémentation RLP
op<0>
op<5>. .op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
op<5>. .<0>
R-type ori lw sw beq jumpRegWr
ALUSrc
MemtoReg
MemWr
nPCsel
Jump
RegDst
ExtOp
ALUop<2>
ALUop<1>
ALUop<0>
Architecture des Ordinateurs 176
Assembler tout!
32
ALUctr
Clk
busW
RegWr
32
32
busA
32
busB
55 5
Rw Ra Rb
Rs
Rt
Rt
RdRegDst
Extender
Mux
Mux
3216imm16
ALUSrc
ExtOp
Mux
MemtoReg
Clk
Data InWrEn
32
Adr
Mémoiredonnées
32
MemWr
ALU
InstructionFetch Unit
Clk
Zero
Instruction<31:0>
0
1
0
1
01<
21
:25
>
<1
6:2
0>
<11
:15
>
<0
:15
>
Imm16RdRsRt
Contrôleprincipal
op
6
ALUContrôlefunc
6
3
ALUopALUctr
3RegDst
ALUSrc
:Instr<5:0>
Instr<31:26>
Instr<15:0>
nPC_sel
Registres32x32-bits
Architecture des Ordinateurs 177
Temps Op. chargement (le pire des extrêmes)Clk
PC
Rs, Rt, Rd,Op, Func
Temps Propagation PC
ALUctr
Accés mémoire pour Instruction
Valeur Anc. Nouv. Valeur
RegWr Valeur Anc. Nouv. Valeur
Délai Logique de Contrôle
busATemps Accès Registres
Valeur Anc. Nouv. Valeur
busB
Délai ALU
Valeur Anc. Nouv. Valeur
Valeur Anc. Nouv. Valeur
Nouv. Valeur
Valeur Anc.
ExtOp Valeur Anc. Nouv. Valeur
ALUSrc Valeur Anc. Nouv. Valeur
MemtoReg Valeur Anc. Nouv. Valeur
Address Valeur Anc. Nouv. Valeur
busW Valeur Anc. Nouv. Valeur
Délai Ext & Mux
Ecriture registres
Temps Accés mémoire
Architecture des Ordinateurs 178
Inconvénients du processeur monocycle
• Cycle horloge Long:– Cycle doit être suffisant pour Instruction de chargement :
Temps propagation PC +Temps Accès Mémoire +Temps Accès Banc registres +Délai ALU (calcul adresse données) +Temps accès mémoire (chargement données) +Temps établissement Banc registres (écriture données) +Temps désalignement
• Longueur cycle horloge pour chargement DEPASSE DE LOIN les nécessités des autres instructions
Architecture des Ordinateurs 179
Conclusions• Chemin données monocycle => CPI=1, CCT => long
• 5 étapes pour conception de processeur1. Analyse jeux instructions => Exigences chemin données2. Sélection des composants & établissement méthodologie horloge3. Assemblage du chemin données pour réalisation des exigences4. Analyse de l implémentation de chaque instruction pour déterminer les
valeurs nécessaires des contrôles5. Assemblage du logique de contrôle
• Contrôle est le plus difficile
• MIPS facilite la logique de contrôle– Instructions même taille– Source registres toujours même place dans instruction– Immédiate toujours mêmé place et taille– Opérations toujours sur registres/immédiate
Contrôle
Chem. D.
Mémoire
ProcesseurEntrées
Sorties
Architecture des Ordinateurs 180
CHAPITRE V:Conception de microprocesseur multi-cycles
Architecture des Ordinateurs 181
Chemin de données pour multi-cycles
Architecture des Ordinateurs 182
Vue simplifiée du processeur monocycle
PC
PC
Sui
v.
Lect
ure
Reg
istr
es
ALU
Ecr
itR
egs.
Acc
ès
Mém
oire
Mem
Don
n.Lect
ure
Inst
ruct
ion
Ran
gem
ent
Rés
ulta
t
ALU
ctr
Reg
Dst
ALU
Src
Ext
Op
Mem
Wr
Co
nd
=
nP
C_
sel
Reg
Wr
Mem
Wr
Mem
Rd
ContrôlePrincipal
ContrôleALU
op
fun
Ext
Architecture des Ordinateurs 183
Réduction du temps de l’instruction• Insertion de registres intermédiaires• Même travail fait dans plusieurs cycles courts, au
lieu d'un seul cycle long
Logique combinatoire
Registre
=>
Logique combinatoire A
Logique combinatoire B
Registre
Registre
Registre
Registre
Architecture des Ordinateurs 184
Segmentation du chemin de données
Ajout de registres entre étapes intermédiaires
PC
PC
Sui
v.
Lect
ure
Arg
umen
tsExec B
anc
Reg
.
Acc
èsM
émoi
re
Mem
.D
onn.
Lect
ure
Inst
ruct
ion
Ran
gem
ent
Rés
ulta
t
ALU
ctr
Reg
Dst
ALU
Src
Ext
Op
Mem
Wr
nP
C_
sel
Reg
Wr
Mem
Wr
Mem
Rd
Architecture des Ordinateurs 185
Chemin de données multi-cycles
Chemin critique ?
PC
Lect
ure
Inst
ruct
ion
Ext
ALU Ban
cR
eg.
Acc
ésM
em.
Mem
.D
onn
ALU
ctr
Reg
Dst
ALU
Src
Ext
Op
nP
C_
sel
Reg
Wr
Mem
Wr
Mem
Rd
IR
A
B
S
M
BancReg.
Mem
ToR
eg
Con
d=
PC
Sui
v.
Architecture des Ordinateurs 186
Etapes de conceptionEtape 1: ISA => Registres Transferts Logique
Etape 2: Composants de Chemin Données
Etape 3: RTs + Composants => Chemin données
Etape 4: Chemin + RTs Logique => RTs Physique
Etape 5: RTs Physique => Contrôle
Architecture des Ordinateurs 187
Etape 4: type-R (add, sub, . . .)• Transferts logiques des registres
• Transferts Physiques des registres
ADD R[rd] <– R[rs] + R[rt]; PC <– PC + 4
IR <– MEM[pc]
ADD A<– R[rs]; B <– R[rt]
S <– A + B
R[rd] <– S; PC <– PC + 4
Exe
c
Ban
cR
eg.
Acc
ésM
emoi
re
Mem
.D
onn
A
B
S
M
Ban
cR
eg.
PC
PC
Sui
v.
IR
Mem
. Ins
t.
Architecture des Ordinateurs 188
Etape 4: OR logique
ORI R[rt] <– R[rs] OR ZeroExt(Im16); PC <– PC + 4
IR <– MEM[pc]
ORI A<– R[rs]; B <– R[rt]S <– A or ZeroExt(Im16)
R[rt] <– S; PC <– PC + 4
Exe
c
Ban
cR
eg.
Acc
ésM
emoi
re
Mem
.D
onn
A
B
S
M
Ban
cR
eg.
PC
PC
Sui
v.
IR
Mem
. Ins
t.
• Transferts logique des registres
• Transferts Physiques des registres
Architecture des Ordinateurs 189
Etape 4 : chargement
LW R[rt] <– MEM(R[rs] + SignExt(Im16);
PC <– PC + 4
IR <– MEM[pc]
LW A<– R[rs]; B <– R[rt]
S <– A + SignExt(Im16)
M <– MEM[S]
R[rd] <– M ; PC <– PC + 4
Exe
c
Ban
cR
eg.
Acc
ésM
emoi
re
Mem
.D
onn
A
B
S
M
Ban
cR
eg.
PC
PC
Sui
v.
IR
Mem
. Ins
t.
• Transferts logiques des registres
• Transferts Physiques des registres
Architecture des Ordinateurs 190
Etape 4 : rangementSW MEM(R[rs] + sx(Im16) <– R[rt];
PC <– PC + 4
IR <– MEM[pc]
SW A<– R[rs]; B <– R[rt]
S <– A + SignEx(Im16);
MEM[S] <– B PC <– PC + 4
Exe
c
Ban
cR
eg.
Acc
ésM
emoi
re
Mem
.D
onn
A
B
S
M
Ban
cR
eg.
PC
PC
Sui
v.
IR
Mem
. Ins
t.
• Transferts logiques des registres
• Transferts Physiques des registres
Architecture des Ordinateurs 191
Etape 4 : saut conditionnelBEQ Si R[rs] == R[rt]
Alors PC <= PC + SignExt(Im16) +4
Sinon PC <= PC + 4
IR <– MEM[pc]
BEQ|Cond= PC <– PC + 4
IR <– MEM[pc].
BEQ|Cond= PC <– PC +
SignExt(Im16)+4
Exe
c
Ban
cR
eg.
Acc
ésM
emoi
re
Mem
.D
onn
A
B
S
M
Ban
cR
eg.
PC
PC
Sui
v.
IR
Mem
. Ins
t.
• Transferts logiques des registres
• Transferts Physiques des registres
Architecture des Ordinateurs 192
Chemin de données multi-cycles du livreMinimisation du matériel: 1 mémoire, 1 ALU/adder
MémoireIdéale
WrAdrDin
RAdr
32
32
32Dout
MemWr
32
ALU
3232
ALUOp
ContrôleALU
Reg Inst.
32
IRWr
32
BancRegs.
Ra
Rw
busW
Rb5
5
32busA
32busB
RegWr
Rs
Rt
Mux
0
1
Rt
Rd
PCWr
ALUSelA
Mux 01
RegDst
Mux
0
1
32
PC
MemtoReg
Ext
ExtOp
Mux
0
132
0
1
23
4
16Imm 32
<< 2
ALUSelB
Mux
1
0
Dest.32
Cond=
ZeroPCWrCond PCSrc BrWr
32
IorD
Architecture des Ordinateurs 193
Unité de contrôle pour multi-cycles
Architecture des Ordinateurs 194
Modèle du contrôle
• Un état spécifiant les points de contrôle pour les Transferts de Registres.
• Transfert prend place au moment où on quitte l ’état (front descendant).
Etat Courant
Logique étatsuivant
Logique Sorties
Conditions (op, Cond=)
Points de contrôle
Etat X
Transferts de registresPoints de contrôle
Dépend des entrées
Architecture des Ordinateurs 195
Etape 4 => spécification du contrôleIR <= MEM[PC]
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= SPC <= PC + 4
S <= A or ZX
R[rt] <= SPC <= PC + 4
ORi
S <= A + SX
R[rt] <= MPC <= PC + 4
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= BPC <= PC + 4
BEQ & Cond=BEQ & !Cond=
PC <= PC + 4 PC <= PC +SX +4
SW
“chercher instruction”
“lecture/décodage arguments”
Exé
cutio
n
Acc
ès M
em.
Ecr
ire r
egis
tres
Architecture des Ordinateurs 196
Contrôleur traditionnel
Etat
6
4
11EtatSuiv.
op
Cond=
Points Contrôle
Etat op Cond= EtatSuiv.
Points Contrôle
Table Vérité
Chem. Donn.
Architecture des Ordinateurs 197
Etape 5:chemin conn.+digramme états=>contrôle
• Traduire RTS en points de contrôle• Affectation des Etats• Construction Contrôleur
Architecture des Ordinateurs 198
Traduction RTS en points de contrôleIR <= MEM[PC]
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= SPC <= PC + 4
S <= A or ZX
R[rt] <= SPC <= PC + 4
ORi
S <= A + SX
R[rt] <= MPC <= PC + 4
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= BPC <= PC + 4
BEQ & EqualBEQ & !Equal
PC <= PC + 4 PC <= PC +SX || 00
SW
imem_rd, IRen
ALUfun, Sen
RegDst, RegWr,PCen
Aen, Ben
Architecture des Ordinateurs 199
Affectation des états
IR <= MEM[PC]
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= SPC <= PC + 4
S <= A or ZX
R[rt] <= SPC <= PC + 4
ORi
S <= A + SX
R[rt] <= MPC <= PC + 4
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= BPC <= PC + 4
BEQ & EqualBEQ & ~Equal
PC <= PC + 4 PC <= PC +SX || 00
SW
0000
0001
0100
0101
0110
0111
1000
1001
1010
0011 00101011
1100
Architecture des Ordinateurs 200
0000 ?????? ? 0001 10001 BEQ 0 0011 1 10001 BEQ 1 0010 1 10001 R-type x 0100 1 10001 orI x 0110 1 10001 LW x 1000 1 10001 SW x 1011 1 10010 xxxxxx x 0000 1 10011 xxxxxx x 0000 1 00100 xxxxxx x 0101 0 1 fun 10101 xxxxxx x 0000 1 0 0 1 10110 xxxxxx x 0111 0 0 or 10111 xxxxxx x 0000 1 0 0 1 01000 xxxxxx x 1001 1 0 add 11001 xxxxxx x 1010 1 0 01010 xxxxxx x 0000 1 0
1 1 01011 xxxxxx x 1100 1 0 add 11100 xxxxxx x 0000 1 0 0 1
Etat Op Cond= Suiv. IR PC Exec Mem Ecrire Reg.sel A B Ext Sr ALU S R W M M-R Wr Dst
R:ORi:
LW:
SW:
Spécification détaillée du contrôle
Architecture des Ordinateurs 201
Evaluation de Performances
• CPI Moyen?– Diagramme des états donne CPI pour chaque
instruction– Fréquence d ’utilisation de chaque instruction
Type CPIi Fréquence CPIi x freqIi
Arith/Logic 4 40% 1.6
Chargement 5 30% 1.5
Rangement 4 10% 0.4
Saut Cond. 3 20% 0.6
Moyenne CPI:4.1
Architecture des Ordinateurs 202
Unité de contrôle pour multi-cycles: implémentation avec compteur à sauts
Architecture des Ordinateurs 203
Conception du contrôleur
• Les diagrammes du contrôle obtenu sont simples et structurés• Utilisation de structure simple pour construction de “micro-
séquenceur” • Implémentation de la logique de contrôle: programmation
– microprogrammation
ContrôleSéquenceur
Contrôle Chem. Donn.
micro-PCséquenceur
microinstruction
Architecture des Ordinateurs 204
Compteur à sauts
op-codeROM
CompteurZeroIncCharg.
0000i
i+1
i
Architecture des Ordinateurs 205
Machine avec compteur à sautsIR <= MEM[PC]
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= SPC <= PC + 4
S <= A or ZX
R[rt] <= SPC <= PC + 4
ORi
S <= A + SX
R[rt] <= MPC <= PC + 4
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= BPC <= PC + 4
BEQ & =BEQ & ~=
PC <= PC + 4 PC <= PC +SX || 00
SW
“Lecture instruction”0000
0001
0100
0101
0110
0111
1000
1001
1010
0011 00101011
1100
inca
Charg. Inc
zero zero
Zero Zero
Zero ZeroInc Inc Inc Inc
inc
Architecture des Ordinateurs 206
Le micro-séquenceur
op-code
ROM
Micro-PC
Z I CContrôle chemin données
Cod=
Architecture des Ordinateurs 207
0000 ? inc 10001 0 charg0001 1 inc0010 x zero 1 10011 x zero 1 00100 x inc 0 1 fun 10101 x zero 1 0 0 1 10110 x inc 0 0 or 10111 x zero 1 0 0 1 01000 x inc 1 0 add 11001 x inc 1 0 01010 x zero 1 0
1 1 01011 x inc 1 0 add 11100 x zero 1 0 0 1
µPC Cond= ZIC IR PC Exec Mem Ecrire Regs.en sel A B Ext Sr ALU S R W M M-R Wr Dst
R-Type:
ORi:
LW:
SW:
BEQ
Spécification microprogramme
Architecture des Ordinateurs 208
ROM
R-type 000000 0100
BEQ 000100 0011
ori 001101 0110
LW 100011 1000
SW 101011 1011
Architecture des Ordinateurs 209
Contrôle de la mémoire
PC
Mémoire Instruction
IR
adresse
données
IR_en
InstMem_rd
IM_wait
Architecture des Ordinateurs 210
Contrôleur pour mémoire non-idéaleIR <= MEM[PC]
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= SPC <= PC + 4
S <= A or ZX
R[rt] <= SPC <= PC + 4
ORi
S <= A + SX
R[rt] <= MPC <= PC + 4
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= B
BEQ & =BEQ & ~=
PC <= PC + 4 PC <= PC +SX || 00
SW
~wait wait
~wait wait
PC <= PC + 4
~wait wait
Architecture des Ordinateurs 211
Unité de contrôle pour multi-cycles: implémentation avec microprogrammation
Architecture des Ordinateurs 212
Stratégies d’implémentation d’unités de contrôle
Représentation Initiale Machine à états finis Microprogramme
Contrôle séquencement Fonction Compteur microprog. état suivant
+ ROMs distribution
Représentation logique Equations logiques Tables vérité
Implémentation RLP ROM technique
« Contrôle câblé» « Contrôle microprogrammé»
Architecture des Ordinateurs 213
Chemin de données1 mémoire, 1 ALU
MémoireIdéale
WrAdrDin
RAdr
32
32
32Dout
MemWr
32
ALU
3232
ALUOp
ALUControl
Reg Instruction
32
IRWr
32
Banc Reg
Ra
Rw
busW
Rb5
5
32busA
32busB
RegWr
Rs
Rt
Mux
0
1
Rt
Rd
PCWr
ALUSelA
Mux 01
RegDst
Mux
0
1
32
PC
MemtoReg
Ext
ExtOp
Mux
0
132
0
1
23
4
16Imm 32
<< 2
ALUSelB
Mux
1
0
Target32
Cond=
ZeroPCWrCond PCSrc TrWr
32
IorD
ALU
Out
Architecture des Ordinateurs 214
Microprogrammation
• Contrôle: partie difficile de la conception– Chemin de données est presque standard et organisé– Mémoire est standard– Contrôle change toujours avec un aspect global (complexe)
Microprogrammation:
• Une stratégie pour l'implémentation de l ’UC par la programmation au niveau transfert registres.
Micro architecture:
• Structure logique et fonctionnalités du hardware tel que vue par le microprogrammeur
Architecture des Ordinateurs 215
Unité de contrôle microprogrammé
Opcode
Reg. Etat
Entrée
Sorties
Logique de Contrôle Chemin de donnéesMulti-cycles
1
Sélection Adresse
Add
Types de “Saut” :• Etat = zéro• Distribuer (Etat 1)• Etat = inc.
Architecture des Ordinateurs 216
Interprétation “macro instruction”
MémoirePrincipale
Mémoire de Contrôle
CPU
ADDSUBAND
DATA
.
.
.
Application +Données
Micro-séquence pour AND
e.g., Lire InstructionLire ArgumentCalculerEnregistrer résultat
Architecture des Ordinateurs 217
Variantes de microprogrammation
° Horizontale
– Un champ de contrôle pour chaque point de contrôle dans le chemin de données.
° Verticale
– Micro-instructions compactes : champ pour codifier chaque classe de micro-opérations.
– Décoder en local pour générer les point de contrôle.
Architecture des Ordinateurs 218
Horizontal: cas extrême
N3 N2 N1 N0. . .
13
Inc. PCALU contrôle
1 bit pour chaque registreenbMARenbAC. . .
Remarques :
•Plusieurs combinaisons inutiles et ne peuvent se passer en parallèle.
�codifier pour diminuer l ’espace ROM
•Exemple: mem-reg and ALU-reg ne peuvent se passer en parallèle;
� champ: source-écriture-registres, 1 seul bit décoder au lieu de 2 séparer
Codification doit permettre le maximum de parallélisme possiblepar le chemin de données.
Architecture des Ordinateurs 219
Conception des micro-instructions1) Liste des points de contrôle
2) Grouper les points : définir les « champs »
3) Placer les champs dans la séquence logique (exemple, ALU opération & ALU arguments avant le séquencement de micro-instructions)
4) Créer une légende symbolique du format de micro-instruction: désignation de chaque champ, valeurs possibles, action sur les points de contrôles
5) Minimiser la largeur de micro-instruction, codifier les opérations qui ne peuvent se passer en parallèle.
Architecture des Ordinateurs 220
Désignation Effet quand « vrai » Effet quand « faut »ALUSelA ALU arg. 1 = PC ALU arg. 1 = Reg[rs]RegDst Reg. dest. = rt Reg. dest. = rdTargetWrite Target reg. = ALU RegWrite None Ecrire reg. MemtoReg Données reg. = ALU Données reg. = mémoireIRWrite IR = M émoireMemWr Ecrire m émoire IorD adresse mémoire = PC adresse mémoire = ALU
Désignation Valeur EffetALUOp 00 ALU add
01 ALU sub 10 ALU funct11 ALU OR
ALUSelB 000 ALU arg. 2 = Reg[rt] 001 ALU arg. 2 = 4 010 ALU arg. 2 = sx IR[15-0] 011 ALU arg. 2 = sx, shift left 2 IR[15-0]100 ALU arg. 2 = zx IR[15-0]
PCSource 0 PC = ALU 1 PC = Target PCWritePC = PCSource
PCWriteCond IF Cond= then PC = PCSource
Liste des points de contrôle
Architecture des Ordinateurs 221
Liste des points de contrôle (suite)• Etat suivant -- adresse micro-instruction suivante
–« micro PC» ou « µPC »Design. Valeur EffetSéquencement 00 µadresse suiv. = 0
01 µadresse suiv. = ROM de distribution.
10 µadresse suiv. = µadresse + 1
Opcode
Micro.PC
SélectionµAdresse
Suiv.
Add.
ROM
Mux.012
1
Architecture des Ordinateurs 222
Format micro-instruction: codification
Champ Largeur Points de Contrôle
Contrôle ALU 2 ALUOpSRC1 1 ALUSelASRC2 2 ALUSelBDestination ALU 1 RegWrite, MemtoReg, RegDst, TargetWr.Mémoire 2 MemRead, MemWrite, IorD
Registre mémoire 2 IRWrite, RegWr, MemtoReg, RegDest EcrirePC 2 PCWrite, PCWriteCond, PCSourceSéquencement 2 AddrCtlTotal 14 bits
Architecture des Ordinateurs 223
LégendeChamp Valeur Fonction ALU Add ALU add
Subt. ALU subFunc ALU funcOr ALU OR
SRC1 PC ALU 1 = PCrs ALU 1 = Reg[rs]
SRC2 4 ALU 2 = 4Sx ALU 2 = sx IR[15-0]Zx ALU 2 = zx IR[15-0] Dec ALU 2 = sx/sl IR[15-0]rt ALU 2 = Reg[rt]
Destination ALU Target Target = ALUoutrd Reg[rd] = ALUout
Mémoire Lire PC Lire m émoire avec PCLire ALU Lire m émoire avec ALU outputEcrire Ecrire Reg[rt], ALU sortie adresse
Registre Mémoire IR IR = MemEcrire rt Reg[rt] = MemLire rt Mem = Reg[rt]
Ecrire PC ALU PC = ALU outputTarget-cond. IF Cond= then PC = Target
Séquencement Seq µinstruction suivanteZero première microinstructionDistribution distribution avec ROM/Opcode.
Architecture des Ordinateurs 224
Le Microprogramme!Etiquet. ALU SRC1 SRC2 ALU Dest. Mémoire Re. Mem EcrirePC Séquence.
Fetch Add PC 4 Lire PC IR ALU SeqAdd PC Dec Target Distrib.
LW Add rs Sx SeqLire ALU Lire rt Fetch
SW Add rs Sx SeqEcrire ALU Lire rt Fetch
Rtype Func. rs rt Seqrd Fetch
BEQ1 Sub rs rt Target– cond. FetchJUMP1 jump address FetchORI Or rs Zx Seq
rd Fetch
Architecture des Ordinateurs 225
Evaluation de la microprogrammation
° Facilité et structure de la conception
° Flexibilité• Adaptation aux changements dans l ’organisation, timing, et
technologie• Possible de faire des changements à la fin du cycle de conception
° Facile de rendre le jeu d’instructions plus puissant (il suffit d’agrandir la mémoire de contrôle)
° Généralités• Implémentation de jeux d’instructions multiples sur une même
machine• Jeux d’instruction sur mesure pour application
° Implémentation coûteuse
° Lenteur
Architecture des Ordinateurs 226
Exceptions
• Exception = traitement anormal – système traite l’exception
• enregistrer l’adresse de l ’instruction cause
– retour à l’exécution du programme de l’utilisateur– sauvegarde du contexte (état) du programme utilisateur
Programme Utilisateur
TraitementException(système)Exception:
Retour de l ’exception
Architecture des Ordinateurs 227
Types d ’Exceptions
• Interruptions Externes– Causées par des événements externes– Exécutées entre instructions (terminer
instruction courante)– simple suspension et reprise du programme en
cours• Interruptions Internes
– Causées pardes événements internes• conditions exceptionnelles (débordement)• erreurs (parité des données mémoire)• fautes (page cache non-résidente)
– instruction peut être réessayée; programme peut être repris ou terminé
Architecture des Ordinateurs 228
Conventions MIPS
•Exception : tout changement inattendu du traitement normal; pas de différence entre interne et externe
•Terme « interruption » utilisé seulement pour les événements externes
• Type événement Origine? MIPS Requête dispositif E/S Externe InterruptionInvocation Noyau Interne ExceptionDébordement Interne ExceptionInstruction indéfinie Interne ExceptionDysfonctionnement matériels Externe ou Exception or
Interne Interruption
Architecture des Ordinateurs 229
Transfert au traitement exception
• Vecteur Interruptions– PC <- MEM[ VI_base + cause || 00]– 370, 68000, Vax, 80x86, . . .
• Table Interruptions– PC <– IT_base + cause || 0000– Sparc, . . .
• Approche MIPS: Adresse Fixe– PC <– EXC_addr
VI_basecause
TraitementException
TI_basecause
Traitement Exception
Architecture des Ordinateurs 230
Changements conception?
• EPC–a 32-bits registre pour sauvegarde de l ’adresse de l ’instruction cause de l ’exception
• Cause– registre utilisé pour sauvegarde de raison de l ’exception. bits 2 à 5 pour codifier la raison:– 0 (INT) => interruption– 4 (ADDRL) => erreur adresse– 10 (RI) => instruction indéfinie– 12 (OVF) => débordement
• Signaux de contrôle pour écrire EPC , Cause • Ecrire adresse fixe au PC, ajout au mux PC une entrée
pour 01000000 00000000 00000000 00000000• PC = PC - 4!
Architecture des Ordinateurs 231
Modifications du contrôleIR <= MEM[PC]PC <= PC + 4
R-type
A <= R[rs]B <= R[rt]
S <= A fun B
R[rd] <= S
S <= A op ZX
R[rt] <= S
ORi
S <= A + SX
R[rt] <= M
M <= MEM[S]
LW
S <= A + SX
MEM[S] <= B
SW
Autre (instruction indéfinie)
EPC <= PC - 4PC <= exp_addrcause <= 10 (RI)
EPC <= PC - 4PC <= exp_addrcause <= 12 (Ovf)
débordementCond=
BEQ
PC <= PC +SX || 00
0010
0011
S <= A - B ~Cond=
Architecture des Ordinateurs 232
CHAPITRE VI:Conception de microprocesseur multi-cycles
Architecture des Ordinateurs 233
Notions d’exécution en pipeline
Architecture des Ordinateurs 234
Notions de Pipeline
• 4 personnes ; chacun doit :laver, sécher, repasser, ranger
• lavage : 30 minutes
• séchage : 40 minutes
• Repassage : 30 minutes
• Rangement : 20 minutes
A B C D
Exemple: Opération de lavage du linge
Architecture des Ordinateurs 235
Lavage du linge en séquentiel
• 8 heures pour terminer
30Ordre
Tâches
B
C
D
ATime
30 40 2030 40 2030 30 40 2030 30 40 2030
6 PM 7 8 9 10 11 12 1 2 AM
Architecture des Ordinateurs 236
Lavage linge en pipeline6 PM 7 8 9 10 1
1Temps
B
C
D
A4030 40 4040 30 20
Ordre
Tâches
4 heures !
Architecture des Ordinateurs 237
Remarques sur le traitement en pipeline
• Traitement en pipeline n ’améliore pas le temps de chaque tâche, mais le débit des opérations
• Tâches multiples en parallèles avec ressources différentes
• Gain de temps = Nombre d ’étages• Débit de pipeline est limité par l ’étage le plus
lent • Longueur non-équilibrée réduit le gain de temps• Temps pour « remplir » et « décharger »
pipeline réduit le gain de temps
Architecture des Ordinateurs 238
5 Etages pour Chargement (LW)
• Ifetch: Lecture de l ’instruction• Reg/Dec: Lecture des registres et
décodage instruction • Exec: Calculer l ’adresse mémoire• Mem: Lecture de mémoire données• Wr: Ecriture dans les registres• Chemin données : Insertion d ’autres
registres intermédiaires (entre étages) pour permettre traitement pipeline
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5
Ifetch Reg/Dec Exec Mem WrLW
Architecture des Ordinateurs 239
Représentation d’exécution en pipeline
IFetch Dcd Exec Mem WB
IFetch Dcd Exec Mem WB
IFetch Dcd Exec Mem WB
IFetch Dcd Exec Mem WB
IFetch Dcd Exec Mem WB
IFetch Dcd Exec Mem WBDéroulement du programme
Temps
Architecture des Ordinateurs 240
Comparaison: monocycle, multi-cycle, pipeline
Clk
Cycle 1
Implémentation multi-cycle:
Ifetch Reg Exec Mem Wr
Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9Cycle 10
LW Ifetch Reg Exec Mem Wr
Ifetch Reg Exec Mem
LW SW
Implémentation pipeline:
Ifetch Reg Exec Mem WrSW
Clk
Implémentation monocycle:
LW SW Perte
Ifetch
R-type
Ifetch Reg Exec Mem WrR-type
Cycle 1 Cycle 2
Architecture des Ordinateurs 241
Pourquoi le pipeline?
• Exécution de 100 instructions:Machine monocycle (10+7+10+10+7)–45 ns/cycle x 1 CPI x 100 inst = 4500 ns
Machine multi-cycle– 10 ns/cycle x 4.4 CPI (mixte d ’instructions) x
100 inst = 4400 nsMachine en pipeline– 10 ns/cycle x (1 CPI x 100 inst + 4 cycles
décharg.) = 1040 ns
Architecture des Ordinateurs 242
Aléas de pipeline et méthodes de résolution
Architecture des Ordinateurs 243
Ressources disponibles?
Temps (cycles)
Inst 0
Inst 1
Inst 2
Inst 4
Inst 3A
LUIm Reg Dm Reg
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
Architecture des Ordinateurs 244
Problèmes avec les pipelines?
• Types d ’aléas (« hazards ») :– Aléas de structure: utilisation d’une même ressource
plusieurs fois en même temps
– Aléas de données: utilisation d’une donnée avant qu’elle ne soit prête
• instruction dépend des résultas d ’une instruction antérieure encore dans le pipeline
– Aléas de contrôle: prendre une décision avant d’évaluer la condition
• instruction de saut conditionnel
• Aléas résolus par suspension (attente)– contrôle du pipeline doit détecter l’aléa – prendre l’action nécessaire pour résoudre l’aléa
Architecture des Ordinateurs 245
Mémoire : aléas de structure
Mem
Temps
Load
Instr 1
Instr 2
Instr 3
Instr 4A
LUMem Reg Mem Reg
ALUMem Reg Mem Reg
ALUMem Reg Mem Reg
ALUReg Mem Reg
ALUMem Reg Mem Reg
Détection facile. Solution limite la performance!
Architecture des Ordinateurs 246
Aléas de contrôle• Suspension: attendre jusqu’à ce que la décision puisse
être prise – possible de prendre la décision en cycle 2 par ajout de hardware
• Impact: 2 cycles / instruction de saut conditionnel => lenteur
Temp (en cycles)
Add
Beq
Load
ALUMem Reg Mem Reg
ALUMem Reg Mem Reg
ALUReg Mem RegMem
Architecture des Ordinateurs 247
Aléas de Contrôle
• Prédiction: suppose une des deux possibilités, et correction en cas d ’erreur
• Impact: 1 cycle/ instruction saut si prédiction est correcte, 2 cycles en cas d ’erreur (correcte - 50%)
Temps (en cycles)
Add
Beq
Load
ALUMem Reg Mem Reg
ALUMem Reg Mem Reg
MemA
LUReg Mem Reg
Architecture des Ordinateurs 248
Aléas de contrôle
• Redéfinir saut conditionnel: avec effet après instruction suivante (saut avec effet retardé)
• Impact: 0/cycle par instruction saut si on peut remplir la case instruction après saut
Temps (en cycles)
Add
Beq
Misc
ALUMem Reg Mem Reg
ALUMem Reg Mem Reg
Mem
ALUReg Mem Reg
Load Mem
ALUReg Mem Reg
Architecture des Ordinateurs 249
Aléas de données sur r1
add r1 ,r2,r3
sub r4, r1 ,r3
and r6, r1 ,r7
or r8, r1 ,r9
xor r10, r1 ,r11
Architecture des Ordinateurs 250
Aléas de donnée sur r1• Dépendances en arrière
Temps (en cycles)
add r1,r2,r3
sub r4, r1,r3
and r6, r1,r7
or r8, r1,r9
xor r10, r1,r11
IF
ID/Rg
EX
MEM
ERALUIm Reg Dm Reg
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
Im
ALUReg Dm Reg
ALUIm Reg Dm Reg
Architecture des Ordinateurs 251
Solution Aléas de Données:
• “Renvoyer” résultat d ’une étape vers une autre
Temps (en cycles)
add r1,r2,r3
sub r4, r1,r3
and r6, r1,r7
or r8, r1,r9
xor r10, r1,r11
IF
ID/RF
EX
MEM
WB
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
Im
ALUReg Dm Reg
ALUIm Reg Dm Reg
• “or” OK ?
Architecture des Ordinateurs 252
Aléas de données: cas Load• Dépendances en arrière
• Renvoi impossible • Suspension est la seule solution!
Temps (en cycles)
lw r1,0(r2)
sub r4, r1,r3
IF
ID/RF
EX
MEM
WB
ALUIm Reg Dm Reg
ALUIm Reg Dm Reg
Architecture des Ordinateurs 253
Notions de chemin de données de pipeline
Architecture des Ordinateurs 254
Conception du processeur avec pipeline
• Revoir le chemin de données et le diagramme de contrôle
• Association des ressources aux états
• Résolution de tous les conflits (aléas)
• Assertion de contrôle à chaque étape
Architecture des Ordinateurs 255
Processeur avec pipeline
• Une instruction à chaque cycle?
Exe
c
Ban
cR
egs.
Mem
Acc
ess
Dat
aM
em
A
B
S
M
Reg
File
Con
d=
PC
Nex
t PC
IR
Inst
. Mem
Valid
IRex
Dcd
Ctr
l
IRm
em
Ex
Ctr
l
IRw
b
Mem
Ctr
l
WB
Ctr
l
Architecture des Ordinateurs 256
Processeur avec pipeline
EI/DI DI/EX EX/MEM MEM/ER
Contrôle
ER
M
EX
ER
M
ER
Architecture des Ordinateurs 257
chemin & contrôle
IR <- Mem[PC]; PC <– PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B;
R[rd] <– S;
S <– A + SX;
M <– Mem[S]
R[rd] <– M;
S <– A or ZX;
R[rt] <– S;
S <– A + SX;
Mem[S] <- B
If CondPC < PC+SX;
Architecture des Ordinateurs 258
Instruction de chargement
• Les 5 unités indépendantes du chemin données pipeline:– Mémoire Instruction pour étape Ifetch – Port lecture du Banc Registres (bus A et bus B) pour
étape Reg/Dec– ALU pour étape Exec– Mémoire données pour étape Mem– Banc Registres port écriture (bus W) à l ’ étape Wr
Clock
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7
Ifetch Reg/Dec Exec Mem Wr1er lw
Ifetch Reg/Dec Exec Mem Wr2em lw
Ifetch Reg/Dec Exec Mem Wr3em lw
Architecture des Ordinateurs 259
Instruction type-R
• Ifetch – Lecture de l ’instruction de mémoire instructions
• Reg/Dec– Lecture registres et décodage de l ’instruction
• Exec– Opération ALU sur les deux registres
• Wr– Ecriture résultat dans un registre
Cycle 1 Cycle 2 Cycle 3 Cycle 4
Ifetch Reg/Dec Exec WrR-type
Architecture des Ordinateurs 260
Pipeline avec type-R et Load
• Un conflit (aléas de structure):–Deux instructions :écriture dans le Banc
registre en même temps!–Un seul port écriture
Clock
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9
Ifetch Reg/Dec Exec WrR-type
Ifetch Reg/Dec Exec WrR-type
Ifetch Reg/Dec Exec Mem WrLoad
Ifetch Reg/Dec Exec WrR-type
Ifetch Reg/Dec Exec WrR-type
Problème!
Architecture des Ordinateurs 261
Observations importantes• Chaque unité ne peut être utilisée plus d ’une seule
fois par instruction• Chaque unité doit être utilisée dans la même étape
à chaque instruction:– Chargement utilise port écriture du banc registre dans la 5em étape
– R-type utilise le port écriture du banc registre dans la 4ème étape
Ifetch Reg/Dec Exec Mem WrLoad
1 2 3 4 5
Ifetch Reg/Dec Exec WrR-type
1 2 3 4
2 manières pour résoudre ce problème.
Architecture des Ordinateurs 262
Solution 1: suspension du pipeline
• Insertion de “bulle” pour élimination de conflit:– Logique de contrôle compliquée.– Pas de démarrage de nouvelle instruction.
• Pas de démarrage d’instruction en Cycle 6!
Clock
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9
Ifetch Reg/Dec Exec WrR-type
Ifetch Reg/Dec Exec
Ifetch Reg/Dec Exec Mem WrLoad
Ifetch Reg/Dec Exec WrR-type
Ifetch Reg/Dec Exec WrR-type Bulle
Pipeline
Ifetch Reg/Dec Exec Wr
Architecture des Ordinateurs 263
– Écriture dans le banc registre se fait au cycle 5 au lieu de 4– NOOP (pas d’opération) pour étape Mem
Clock
Cycle 1 Cycle 2 Cycle 3 Cycle 4 Cycle 5 Cycle 6 Cycle 7 Cycle 8 Cycle 9
Ifetch Reg/Dec Mem WrR-type
Ifetch Reg/Dec Mem WrR-type
Ifetch Reg/Dec Exec Mem WrLoad
Ifetch Reg/Dec Mem WrR-type
Ifetch Reg/Dec Mem WrR-type
Ifetch Reg/Dec Exec WrR-type Mem
Exec
Exec
Exec
Exec
1 2 3 4 5
Solution 2: ralentir type-R
Architecture des Ordinateurs 264
Modifications chemin & contrôle
IR <- Mem[PC]; PC <– PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B;
R[rd] <– M;
S <– A + SX;
M <– Mem[S]
R[rd] <– M;
S <– A or ZX;
R[rt] <– M;
S <– A + SX;
Mem[S] <- B
if Cond PC < PC+SX;
M <– S M <– S
Architecture des Ordinateurs 265
Les 4 étapes du rangement
• Ifetch: Lecture instruction de mémoire instructions
• Reg/Dec: Lecture registres et décodage instruction
• Exec: Calcul adresse mémoire• Mem: Ecriture données dans mémoire
données
Cycle 1 Cycle 2 Cycle 3 Cycle 4
Ifetch Reg/Dec Exec MemStore Wr
Architecture des Ordinateurs 266
Les 3 étapes du saut conditionnel (Beq)
• Ifetch: Lecture instruction de mémoire instructions
• Reg/Dec: Lecture registres et décodage instruction
• Exec: – Comparaison des deux registres– Sélection de l ’adresse de saut– Chargement PC: Aléas de Contrôle possible!
Cycle 1 Cycle 2 Cycle 3 Cycle 4
Ifetch Reg/Dec Exec MemBeq Wr
Architecture des Ordinateurs 267
Diagramme de contrôle
IR <- Mem[PC]; PC < PC+4;
A <- R[rs]; B<– R[rt]
S <– A + B;
R[rd] <– S;
S <– A + SX;
M <– Mem[S]
R[rd] <– M;
S <– A or ZX;
R[rt] <– S;
S <– A + SX;
Mem[S] <- B
If Cond PC < PC+SX;
M <– S M <– S
Architecture des Ordinateurs 268
Chemin & contrôle
Exe
c
Ban
cR
eg.
Acc
éM
em
Mem
Don
n.
A
B
SBan
cR
eg.
PC
PC
Sui
v.
IR
Mem
Inst
D
Dec
ode
MemCtrl
WB Ctrl
M
rs rtoprs
rt
fun
im
exmewb
v
me
wbv
wb
v
ExecCtrl
Architecture des Ordinateurs 269
Essai d’exécution
10lw r1, r2(35)
14addI r2, r2, 3
20subr3, r4, r5
24beqr6, r7, 100
28ori r8, r9, 17
32addr10, r11, r12
…
100 and r13, r14, 15
Architecture des Ordinateurs 270
Fetch 10
10 lw r1, r2(35)
14 addI r2, r2, 3
20 sub r3, r4, r5
24 beq r6, r7, 100
30 ori r8, r9, 17
34 add r10, r11, r12
…
100 and r13, r14, 15
Exe
c
Ban
cR
eg.
Acc
éM
em
Mem
Don
n.
A
B
S
Ban
cR
eg.
PC
Sui
v.
nM
em In
st
D
Dec
ode
MemCtrl
WB Ctrl
M
rs rt
ExecCtrl
nn n
10
Architecture des Ordinateurs 271
Fetch 14, Decode 10
10 lw r1, r2(35)
14 addI r2, r2, 3
20 sub r3, r4, r5
24 beq r6, r7, 100
30 ori r8, r9, 17
34 add r10, r11, r12
…
100 and r13, r14, 15
Exe
c
Ban
cR
eg.
Acc
éM
em
Mem
Don
n.
A
B
SBan
cR
eg.
PC
Sui
v.
Mem
Inst
D
Dec
ode
n
MemCtrl
WB Ctrl
M
rs rt
n n
ExecCtrl
lw r
1,r2
,3
14
Architecture des Ordinateurs 272
Fetch 20, Decode 14, Exec 10
10 lw r1, r2(35)
14 addI r2, r2, 3
20 sub r3, r4, r5
24 beq r6, r7, 100
30 ori r8, r9, 17
34 add r10, r11, r12
…
100 and r13, r14, 15
Exe
c
Ban
cR
eg.
Acc
éM
em
Mem
Don
n.
A
B
SBan
cR
eg.
PC
Sui
v.
Mem
Inst
D
Dec
ode
MemCtrl
WB Ctrl
M
2 rt
n n
ExecCtrl
lw r
1
addi
r2,
r2,
3
35
20
Architecture des Ordinateurs 273
Fetch 24, Decode 20, Exec 14, Mem 10
10 lw r1, r2(35)
14 addI r2, r2, 3
20 sub r3, r4, r5
24 beq r6, r7, 100
30 ori r8, r9, 17
34 add r10, r11, r12
…
100 and r13, r14, 15
Exe
c
Ban
cR
eg.
Acc
éM
em
Mem
Don
n.
A
B
Ban
cR
eg.
PC
Sui
v.
Mem
Inst
D
Dec
ode
MemCtrl
WB Ctrl
M
4 5
n
ExecCtrlsu
b r3
,r4,
r5
addi
r2,
r2
3
24r2
+35
Lw r
1
Architecture des Ordinateurs 274
CHAPITRE VIII:Systèmes de mémoire
Architecture des Ordinateurs 275
Technologies et types de mémoires
Architecture des Ordinateurs 276
Tendances de technologie
DRAM
Année Taille Temps de Cycle
1980 64 Kb 250 ns
1983 256 Kb 220 ns
1986 1 Mb 190 ns
1989 4 Mb 165 ns
1992 16 Mb 145 ns
1995 64 Mb 120 ns
Capacité Vitesse
DRAM: 4x in 3 années 2x in 10 années
Disques: 4x in 3 année 2x in 10 années
1000:1! 2:1!
Architecture des Ordinateurs 277
Problème de mémoire?
µProc60%/an.(2X/1.5an)
DRAM9%/an.(2X/10 an)1
10
100
100019
8019
81
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
DRAM
CPU
1982
Divergence:(augmentation 50% / an)
Per
form
ance
s
Année
Vitesse Processeur- Vitesse DRAM
Architecture des Ordinateurs 278
Situation actuelle
• Utilisation des caches pour faire le pont entre vitesseprocesseur et vitesse mémoire
• Différence entre performance Microprocesseur etperformance DRAM
– temps pour un défaut de cache en nombre d ’instructions1st Alpha (7000): 340 ns/5.0 ns = 68 clks x 2 or 136 instructions2nd Alpha (8400): 266 ns/3.3 ns = 80 clks x 4 or 320 instructions3rd Alpha (t.b.d.): 180 ns/1.7 ns =108 clks x 6 or 648 instructions
Architecture des Ordinateurs 279
Impact sur performances• Hypothèse: processeur
–Horloge = 200 MHz (5 ns / cycle)
–CPI = 1.1
–50% arith/logic, 30% chargement/rangement, 20% contrôle
• Hypothèse: 10% des accès mémoire avec défaut de cache de 50 cycles
• CPI = CPI idéal + retard moyen par instruction= 1.1(cyc) +( 0.30 (accès mémoire/ins)
x 0.10 (défauts/accès mémoire) x 50(cycles/défaut) )= 1.1 cycle + 1.5 cycle = 2. 6
• 58 % du temps processeur est perdu dans l ’accès mémoire
Architecture des Ordinateurs 280
But: illusion de mémoire grande, rapide, peu coûteuse
• Grandes mémoires sont lentes, et les mémoires rapides sont petites
• Comment créer l ’illusion?–Hiérarchie–Parallélisme
Architecture des Ordinateurs 281
Vue de système mémoire
Contrôle
Chem. Don.
Mémoire
Processeur
Mém
oire
Mémoire
Mémoire
Mém
oire
Plus rapide Plus lente
Plus petite Plus grande
Plus élevé Plus bas
Vitesse:
Taille:
Coût:
Architecture des Ordinateurs 282
Hiérarchie: pourquoi ça fonctionne?
• Le principe de Localité:–Pendant un petit intervalle de temps, le
programme accède à une petite portion de l ’espace adresse
Espace adresse0 2n - 1
Probabilité de référencement
Architecture des Ordinateurs 283
Hiérarchie: comment ça fonctionne?
• Localité Temporelle=> Les éléments récemment référencés sont les plus
proches du processeur
• Localité Spatiale=> Transferts en blocks pour les niveaux supérieurs
NiveauInférieurNiveau
SupérieurAu processeur
Du processeurBlk X
Blk Y
Architecture des Ordinateurs 284
Hiérarchie: terminologie• Succès: élément se trouve dans un block du niveau supérieur
(exemple: Block X) – Taux de succès: la fraction des accès mémoire ayant lieu au niveau supérieur
– Temps de succès: Temps pour accéder au niveau supérieurtemps accès RAM + temps détermination succès ou défaut
• Défaut: élément n ’existe pas dans le niveau supérieur (le ramener d ’un autre niveau: exemple Block Y)– Taux de défaut = 1 - (Taux de succès)
– Pénalité de défaut: Temps pour placer le block au niveau supérieur (remplacer un autre block) +
temps pour livrer élément au processeur
• Temps de succès << Pénalité de défaut NiveauInférieurNiveau
SupérieurAu processeur
Du processeurBlk X
Blk Y
Architecture des Ordinateurs 285
Hiérarchie : typique
• Principe de localité permet de:– Présenter à l ’utilisateur une grande mémoire peu coûteuse .– Un temps d ’accès global proche du temps d ’accès de la
technologie la plus coûteuse.
Contrôle
Cem. Don.
Mémoire Secondaire(Disque)
Processeur
Registres
Mémoire Principale(DRAM)
Cachesecond niveau
(SRAM)
Cache
sur puce1s 10,000,000
(10s ms)Vitesse (ns): 10 100
100sG
Taille (octet):K M
Architecture des Ordinateurs 286
Hiérarchie : gestion
• Registres <-> Mémoire–par compilateur (programmeur?)
• cache <-> mémoire–par le hardware
• mémoire <-> disques–par le hardware et système
d ’exploitation (mémoire virtuelle)–par le programmeur (fichiers)
Architecture des Ordinateurs 287
Hiérarchie : technologie
• Access aléatoire:– Même temps d ’accès pour toutes les adresses– DRAM: Dynamique
• Forte densité, basse consommation d'énergie, peu coûteuse, lente
• rafraîchissement périodique– SRAM: Statique
• basse densité, forte consommation d’énergie, coûteuse, rapide
• pas de rafraîchissement
• Autre type d ’accès:– Temps d ’accès varie d ’une adresse à une autre– Exemples: Disque, CDROM
• Accès séquentiel: temps d’accès linéaire en fonction de l’adresse (e.g.,Bande)
Architecture des Ordinateurs 288
SRAM
• Ecriture:1. Valeur ligne bit (bit=1, ~bit=0)2. Activer sélection mot
• Lecture:1. Pré charger bit et ~bit to Vdd2. Activer sélection mot 3. Cellule décharge bit ou ~bit 4. Détection de différence entre bit et ~bit
Cellule (~ 6 transistors)
~bitbit
Sélection mot
10
0 1
Architecture des Ordinateurs 289
Organisation du SRAM
CelluleSRAM
- +Détection - + - + - +
: : : :
mot 0
mot 1
mot 15
Dout 0Dout 1Dout 2Dout 3
- +ÉcritureLecture - + - + - +
Décodeur A
dresse
WrEnPré charge
Din 0Din 1Din 2Din 3
A0
A1
A2
A3
Architecture des Ordinateurs 290
Interface SRAM
Write Enable (WE_L) actif quand niveau basCombiner Din et Dout: Output enable (OE_L)
nécessaire
– WE_L actif (Low), OE_L inactif (High)• D comme entrée
– WE_L inactif (High), OE_L actif (Low)• D comme sortie
A
DOE_L
2 Nmotsx M bitSRAM
N
M
WE_L
Architecture des Ordinateurs 291
SRAM Timing
Temps Écriture
D
Temps Lecture
WE_L
A
MaintientEcriture
Etablissement Ecriture
Donn. Entrée
Adresse Écriture
OE_L
Imp.
Adresse Lecture
Temps accèsLecture
Donn. Sortie Donn. Sort
Adresse Lecture
Architecture des Ordinateurs 292
DRAM
• Écriture:1. Valeur ligne bit2. Sélection ranger
• Lecture:1. Pré chargement bit à Vdd2. Sélection ranger3. Charge de ligne bit change4. Détection changement de charge sur ligne bit5. Écriture valeur
• Rafraîchissement1. Lecture de chaque cellule
Sélection rangée
bit
Architecture des Ordinateurs 293
Organisation carré du DRAM
Adresse RangéeSélection colonne &Circuit E/S Adresse Colonne
data
Cellule
Architecture des Ordinateurs 294
Intégration de cache et pagination
Architecture des Ordinateurs 295
1 KB Cache Correspondance Directe/ 32 octets par block
Index
0
1
2
3
:
Données du cache
octet 0
0431
:
Etiquette
0x50
V Bit
:
31
octet 1octet 31 :
octet 32octet 33octet 63 :
octet 992octet 1023 :
Etiquette du cache
Octet
9
Architecture des Ordinateurs 296
Taille du block
• Augmentation de taille du block => –augmentation de pénalité de défaut–augmentation de taux de défaut
• Temps accès: – = temps succès x (1 - taux de défaut) + – pénalité défaut x taux défaut
Pénalité Défaut
Taille Block
TauxDéfaut
Temps Accès
Taille Block Taille Block
Architecture des Ordinateurs 297
Cache totalement associatif
• Pas de possibilité de conflit
:
Données
octet 0
0431
:
Etiquette
V Bit
:
octet 1octet 31 :
octet 32octet 33octet 63 :
Etiquette
Octet
X
X
X
X
X
Architecture des Ordinateurs 298
Cache N x associatif
Données
Cache Block 0
EtiquetteV
:: :
Données
Cache Block 0
Etiquette V
: ::
Index
Mux 01Sel1 Sel0
Cache Block
Comp. Comp.
OR
Succès
Architecture des Ordinateurs 299
Inconvénients du cache associatif
• Cache associatif:
– N comparateurs au lieu de 1– Les Mux augmentent le délais– Données disponibles après la décision de défaut ou succès
• Cache correspondance directe
– Données disponibles avant décision de succès/défaut: possibilité de continuer avec supposition de succès
Architecture des Ordinateurs 300
Ecriture?• WT— Ecrire dans cache et dans mémoire à niveau
inférieur
• WB— Ecrire uniquement dans cache. Le block de cache est écrit en mémoire niveau inférieur quand on le remplace (modifier ou non?)
• WT toujours combiné avec tampon d ’écriture
ProcesseurCache
Tampon Ecriture
DRAM
Architecture des Ordinateurs 301
Organisation de mémoire virtuelle
frame 01
7
01024
7168
MémoirePhysique
1K1K
1K
Traduction
page 01
31
1K1K
1K
01024
31744
Mémoire virtuelle
Traduction
Add.Virtuelle
Num. Page offset10
Table des pages
index
Registre base
V Droits Acés A Ph +
Adresse physique
Architecture des Ordinateurs 302
Mémoire virtuelle et cache
Défaut
Processeur Traduction Cache Mémoire
AV AP
SuccèsDonnées
Traduction avant accès cache = > accès cache plus l ent
Solution : TLB cache (traduction anticipée)
Add Virt. Add. Phy. Mo dif. Ref. Valide Accés
Architecture des Ordinateurs 303
Traduction avec TLB
Processeur TLB Cache Mémoire
AVAP/succès défaut
succès
données
Traduction
défaut
20 tt1/2 t