arch a vance

303
Architecture des Ordinateurs 2 ème année Ingénieurs en Informatique Nejib Ben Hadj-Alouane

Upload: mehdi-chihaoui

Post on 24-Oct-2015

68 views

Category:

Documents


4 download

DESCRIPTION

Arch a Vance

TRANSCRIPT

Page 1: Arch a Vance

Architecture des Ordinateurs

2ème année Ingénieurs en Informatique

Nejib Ben Hadj-Alouane

Page 2: Arch a Vance

Architecture des Ordinateurs 2

CHAPITRE I

Introduction

Page 3: Arch a Vance

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

Page 4: Arch a Vance

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).

Page 5: Arch a Vance

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.

Page 6: Arch a Vance

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)

Page 7: Arch a Vance

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...

Page 8: Arch a Vance

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.

Page 9: Arch a Vance

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.

Page 10: Arch a Vance

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,…

Page 11: Arch a Vance

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

Page 12: Arch a Vance

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,…).

Page 13: Arch a Vance

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)

Page 14: Arch a Vance

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.

Page 15: Arch a Vance

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

Page 16: Arch a Vance

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

Page 17: Arch a Vance

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

Page 18: Arch a Vance

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é.

Page 19: Arch a Vance

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.

Page 20: Arch a Vance

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.

Page 21: Arch a Vance

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.

Page 22: Arch a Vance

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.

Page 23: Arch a Vance

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.

Page 24: Arch a Vance

Architecture des Ordinateurs 24

CHAPITRE II:

Rappel systèmes logiques

Page 25: Arch a Vance

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.

Page 26: Arch a Vance

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

Page 27: Arch a Vance

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

Page 28: Arch a Vance

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

Page 29: Arch a Vance

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.

Page 30: Arch a Vance

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

Page 31: Arch a Vance

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 = ?

Page 32: Arch a Vance

Architecture des Ordinateurs 32

Réseau Logique Programmable (RLP)

Représentation Simplifiée

u1

u2

u3

x1

x2

Page 33: Arch a Vance

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))

Page 34: Arch a Vance

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

Page 35: Arch a Vance

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

Page 36: Arch a Vance

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

Page 37: Arch a Vance

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)

Page 38: Arch a Vance

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

Page 39: Arch a Vance

Architecture des Ordinateurs 39

Bistable D (synchrone / front)

D

C

D

C

QBascule

D

D

C

QBascule

D Q

Q

Q

D

Q

C

Page 40: Arch a Vance

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)

Page 41: Arch a Vance

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

Page 42: Arch a Vance

Architecture des Ordinateurs 42

CHAPITRE III:

MIPS ISA

Page 43: Arch a Vance

Architecture des Ordinateurs 43

Organisation d’un ordinateur

Mémoire

Entrées

Sorties

contrôle

Chemin de données

Processeur

Page 44: Arch a Vance

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

Page 45: Arch a Vance

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

Page 46: Arch a Vance

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

Page 47: Arch a Vance

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

Page 48: Arch a Vance

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

Page 49: Arch a Vance

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).

Page 50: Arch a Vance

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

Page 51: Arch a Vance

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

Page 52: Arch a Vance

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

Page 53: Arch a Vance

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).

Page 54: Arch a Vance

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

Page 55: Arch a Vance

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]

Page 56: Arch a Vance

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

Page 57: Arch a Vance

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

Page 58: Arch a Vance

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

Page 59: Arch a Vance

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

Page 60: Arch a Vance

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

Page 61: Arch a Vance

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

Page 62: Arch a Vance

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

Page 63: Arch a Vance

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

Page 64: Arch a Vance

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

Page 65: Arch a Vance

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

Page 66: Arch a Vance

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

Page 67: Arch a Vance

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

Page 68: Arch a Vance

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)

Page 69: Arch a Vance

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

Page 70: Arch a Vance

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

Page 71: Arch a Vance

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

Page 72: Arch a Vance

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

Page 73: Arch a Vance

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

Page 74: Arch a Vance

Architecture des Ordinateurs 74

CHAPITRE IV:Conception des unités arithmétiques

Page 75: Arch a Vance

Architecture des Ordinateurs 75

Notions de baseApproche top-down et bottom-up

Conception UAL

Page 76: Arch a Vance

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…

Page 77: Arch a Vance

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

Page 78: Arch a Vance

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

Page 79: Arch a Vance

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

Page 80: Arch a Vance

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

Page 81: Arch a Vance

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

Page 82: Arch a Vance

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

Page 83: Arch a Vance

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

Page 84: Arch a Vance

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

Page 85: Arch a Vance

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

Page 86: Arch a Vance

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!!

Page 87: Arch a Vance

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).

Page 88: Arch a Vance

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

Page 89: Arch a Vance

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 !

Page 90: Arch a Vance

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

Page 91: Arch a Vance

Architecture des Ordinateurs 91

Conception de UAL à 1 bit

A

Mux

Result

and

or

S-select

B

Les opérations logiques :

Page 92: Arch a Vance

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

Page 93: Arch a Vance

Architecture des Ordinateurs 93

Assemblage (ajout de add)

A

B

1-bitFull

Adder

CarryOut

Mu

x

CarryIn

Result

add

and

or

S-select

Page 94: Arch a Vance

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

Page 95: Arch a Vance

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

Page 96: Arch a Vance

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, …

?

Page 97: Arch a Vance

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

Page 98: Arch a Vance

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!

Page 99: Arch a Vance

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

Page 100: Arch a Vance

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

Page 101: Arch a Vance

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

Page 102: Arch a Vance

Architecture des Ordinateurs 102

Multiplication et division des entiers

Page 103: Arch a Vance

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

Page 104: Arch a Vance

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):

Page 105: Arch a Vance

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?

Page 106: Arch a Vance

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

Page 107: Arch a Vance

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

Page 108: Arch a Vance

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?

Page 109: Arch a Vance

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!

Page 110: Arch a Vance

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

Page 111: Arch a Vance

Architecture des Ordinateurs 111

Comment ça marche?

B0

B1

B2

B3

P0P1P2P3P4P5P6P7

0 0 0 0

A0A1A2A3

A0A1A2A3

A0A1A2A3

A0A1A2A3

Page 112: Arch a Vance

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?

Page 113: Arch a Vance

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

Page 114: Arch a Vance

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

Page 115: Arch a Vance

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.

Page 116: Arch a Vance

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

Page 117: Arch a Vance

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.

Page 118: Arch a Vance

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

Page 119: Arch a Vance

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

Page 120: Arch a Vance

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

Page 121: Arch a Vance

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.

Page 122: Arch a Vance

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

Page 123: Arch a Vance

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)

Page 124: Arch a Vance

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

Page 125: Arch a Vance

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

Page 126: Arch a Vance

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

Page 127: Arch a Vance

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.

Page 128: Arch a Vance

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.

Page 129: Arch a Vance

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

Page 130: Arch a Vance

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

Page 131: Arch a Vance

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”

Page 132: Arch a Vance

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

Page 133: Arch a Vance

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

Page 134: Arch a Vance

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

Page 135: Arch a Vance

Architecture des Ordinateurs 135

Arithmétique de flottants

Page 136: Arch a Vance

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

Page 137: Arch a Vance

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 )

Page 138: Arch a Vance

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

Page 139: Arch a Vance

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

Page 140: Arch a Vance

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

Page 141: Arch a Vance

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

Page 142: Arch a Vance

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

Page 143: Arch a Vance

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

Page 144: Arch a Vance

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

Page 145: Arch a Vance

Architecture des Ordinateurs 145

CHAPITRE V:Conception de microprocesseur monocycle

Page 146: Arch a Vance

Architecture des Ordinateurs 146

Chemin de données pour monocycle

Page 147: Arch a Vance

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.

Page 148: Arch a Vance

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

Page 149: Arch a Vance

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

Page 150: Arch a Vance

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

Page 151: Arch a Vance

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

Page 152: Arch a Vance

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

Page 153: Arch a Vance

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

Page 154: Arch a Vance

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.

Page 155: Arch a Vance

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.

Page 156: Arch a Vance

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

Page 157: Arch a Vance

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

Page 158: Arch a Vance

Architecture des Ordinateurs 158

MIPS chemin données

Page 159: Arch a Vance

Architecture des Ordinateurs 159

Unité de contrôle pour monocycle

Page 160: Arch a Vance

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

Page 161: Arch a Vance

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

=

Page 162: Arch a Vance

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”

Page 163: Arch a Vance

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

Page 164: Arch a Vance

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

Page 165: Arch a Vance

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

Page 166: Arch a Vance

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

Page 167: Arch a Vance

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

Page 168: Arch a Vance

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

Page 169: Arch a Vance

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

Page 170: Arch a Vance

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>

Page 171: Arch a Vance

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>

Page 172: Arch a Vance

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>

Page 173: Arch a Vance

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

:

Page 174: Arch a Vance

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)

Page 175: Arch a Vance

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>

Page 176: Arch a Vance

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

Page 177: Arch a Vance

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

Page 178: Arch a Vance

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

Page 179: Arch a Vance

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

Page 180: Arch a Vance

Architecture des Ordinateurs 180

CHAPITRE V:Conception de microprocesseur multi-cycles

Page 181: Arch a Vance

Architecture des Ordinateurs 181

Chemin de données pour multi-cycles

Page 182: Arch a Vance

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

Page 183: Arch a Vance

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

Page 184: Arch a Vance

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

Page 185: Arch a Vance

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.

Page 186: Arch a Vance

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

Page 187: Arch a Vance

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.

Page 188: Arch a Vance

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

Page 189: Arch a Vance

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

Page 190: Arch a Vance

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

Page 191: Arch a Vance

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

Page 192: Arch a Vance

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

Page 193: Arch a Vance

Architecture des Ordinateurs 193

Unité de contrôle pour multi-cycles

Page 194: Arch a Vance

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

Page 195: Arch a Vance

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

Page 196: Arch a Vance

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.

Page 197: Arch a Vance

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

Page 198: Arch a Vance

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

Page 199: Arch a Vance

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

Page 200: Arch a Vance

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

Page 201: Arch a Vance

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

Page 202: Arch a Vance

Architecture des Ordinateurs 202

Unité de contrôle pour multi-cycles: implémentation avec compteur à sauts

Page 203: Arch a Vance

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

Page 204: Arch a Vance

Architecture des Ordinateurs 204

Compteur à sauts

op-codeROM

CompteurZeroIncCharg.

0000i

i+1

i

Page 205: Arch a Vance

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

Page 206: Arch a Vance

Architecture des Ordinateurs 206

Le micro-séquenceur

op-code

ROM

Micro-PC

Z I CContrôle chemin données

Cod=

Page 207: Arch a Vance

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

Page 208: Arch a Vance

Architecture des Ordinateurs 208

ROM

R-type 000000 0100

BEQ 000100 0011

ori 001101 0110

LW 100011 1000

SW 101011 1011

Page 209: Arch a Vance

Architecture des Ordinateurs 209

Contrôle de la mémoire

PC

Mémoire Instruction

IR

adresse

données

IR_en

InstMem_rd

IM_wait

Page 210: Arch a Vance

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

Page 211: Arch a Vance

Architecture des Ordinateurs 211

Unité de contrôle pour multi-cycles: implémentation avec microprogrammation

Page 212: Arch a Vance

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é»

Page 213: Arch a Vance

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

Page 214: Arch a Vance

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

Page 215: Arch a Vance

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.

Page 216: Arch a Vance

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

Page 217: Arch a Vance

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.

Page 218: Arch a Vance

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.

Page 219: Arch a Vance

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.

Page 220: Arch a Vance

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

Page 221: Arch a Vance

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

Page 222: Arch a Vance

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

Page 223: Arch a Vance

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.

Page 224: Arch a Vance

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

Page 225: Arch a Vance

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

Page 226: Arch a Vance

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

Page 227: Arch a Vance

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é

Page 228: Arch a Vance

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

Page 229: Arch a Vance

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

Page 230: Arch a Vance

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!

Page 231: Arch a Vance

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=

Page 232: Arch a Vance

Architecture des Ordinateurs 232

CHAPITRE VI:Conception de microprocesseur multi-cycles

Page 233: Arch a Vance

Architecture des Ordinateurs 233

Notions d’exécution en pipeline

Page 234: Arch a Vance

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

Page 235: Arch a Vance

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

Page 236: Arch a Vance

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 !

Page 237: Arch a Vance

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

Page 238: Arch a Vance

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

Page 239: Arch a Vance

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

Page 240: Arch a Vance

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

Page 241: Arch a Vance

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

Page 242: Arch a Vance

Architecture des Ordinateurs 242

Aléas de pipeline et méthodes de résolution

Page 243: Arch a Vance

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

Page 244: Arch a Vance

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

Page 245: Arch a Vance

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!

Page 246: Arch a Vance

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

Page 247: Arch a Vance

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

Page 248: Arch a Vance

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

Page 249: Arch a Vance

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

Page 250: Arch a Vance

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

Page 251: Arch a Vance

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 ?

Page 252: Arch a Vance

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

Page 253: Arch a Vance

Architecture des Ordinateurs 253

Notions de chemin de données de pipeline

Page 254: Arch a Vance

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

Page 255: Arch a Vance

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

Page 256: Arch a Vance

Architecture des Ordinateurs 256

Processeur avec pipeline

EI/DI DI/EX EX/MEM MEM/ER

Contrôle

ER

M

EX

ER

M

ER

Page 257: Arch a Vance

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;

Page 258: Arch a Vance

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

Page 259: Arch a Vance

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

Page 260: Arch a Vance

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!

Page 261: Arch a Vance

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.

Page 262: Arch a Vance

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

Page 263: Arch a Vance

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

Page 264: Arch a Vance

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

Page 265: Arch a Vance

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

Page 266: Arch a Vance

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

Page 267: Arch a Vance

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

Page 268: Arch a Vance

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

Page 269: Arch a Vance

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

Page 270: Arch a Vance

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

Page 271: Arch a Vance

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

Page 272: Arch a Vance

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

Page 273: Arch a Vance

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

Page 274: Arch a Vance

Architecture des Ordinateurs 274

CHAPITRE VIII:Systèmes de mémoire

Page 275: Arch a Vance

Architecture des Ordinateurs 275

Technologies et types de mémoires

Page 276: Arch a Vance

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!

Page 277: Arch a Vance

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

Page 278: Arch a Vance

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

Page 279: Arch a Vance

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

Page 280: Arch a Vance

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

Page 281: Arch a Vance

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:

Page 282: Arch a Vance

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

Page 283: Arch a Vance

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

Page 284: Arch a Vance

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

Page 285: Arch a Vance

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

Page 286: Arch a Vance

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)

Page 287: Arch a Vance

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)

Page 288: Arch a Vance

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

Page 289: Arch a Vance

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

Page 290: Arch a Vance

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

Page 291: Arch a Vance

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

Page 292: Arch a Vance

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

Page 293: Arch a Vance

Architecture des Ordinateurs 293

Organisation carré du DRAM

Adresse RangéeSélection colonne &Circuit E/S Adresse Colonne

data

Cellule

Page 294: Arch a Vance

Architecture des Ordinateurs 294

Intégration de cache et pagination

Page 295: Arch a Vance

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

Page 296: Arch a Vance

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

Page 297: Arch a Vance

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

Page 298: Arch a Vance

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

Page 299: Arch a Vance

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

Page 300: Arch a Vance

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

Page 301: Arch a Vance

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

Page 302: Arch a Vance

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

Page 303: Arch a Vance

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