Académique Documents
Professionnel Documents
Culture Documents
Cours Architectures Avancées Dhafer
Cours Architectures Avancées Dhafer
Département de Physique
ARCHITECTURES AVANCEES
Support de Cours
Section : Mastère de Recherche EEA
Niveau : 1 ère Année
N° d’Inventaire : AU 2017/2018
1
Avant Propos
2
Table des matières
Avant Propos..........................................................................................................................................2
CHAPITRE I..............................................................................................................................................7
Introduction à la méthodologie de conception des architectures..........................................................7
1.1. Objectifs.................................................................................................................................8
1.2. Introduction............................................................................................................................8
1.3. Démarche de conception........................................................................................................8
1.4. Rappels sur la logique combinatoire.....................................................................................10
1.4.1. Fonctions Logiques.......................................................................................................10
1.4.2. Les décodeurs : (n entrées, 2n sorties).........................................................................11
1.4.3. Les multiplexeurs..........................................................................................................11
1.4.4. Les démultiplexeurs......................................................................................................12
1.4.5. Les réseaux logiques combinatoires.............................................................................12
1.5. Rappel sur la logique séquentielle........................................................................................13
1.5.1. Horloges........................................................................................................................13
1.5.2. Bascule – bistable (synchrone).....................................................................................13
1.5.3. Banc de registres..........................................................................................................14
1.6. Théorie des architectures....................................................................................................15
1.6.1. Architectures des calculateurs......................................................................................15
1.6.2. Architectures de jeux d’instructions ISA.......................................................................17
1.7. Processus de conception des processeurs pour jeu d’instructions MIPS..............................19
CHAPITRE II...........................................................................................................................................20
Architecture de l’ensemble d’instructions MIPS..................................................................................20
2.1 Objectifs...............................................................................................................................21
2.2 Problématique de conception des systèmes informatiques.................................................21
2.3 Jeu d’instructions MIPS.........................................................................................................22
2.3.1 Opérations du matériel de l’ordinateur........................................................................22
2.3.2 Opérandes du matériel de l’ordinateur........................................................................23
2.4 Représentation des instructions...........................................................................................25
2.4.1 Représentation d’instructions de Type R.....................................................................25
2.4.2 Instructions MIPS..........................................................................................................27
CHAPITRE III..........................................................................................................................................30
Architecture Mono-cycle pour ISA MIPS..............................................................................................30
3.1. Objectifs...............................................................................................................................31
3
3.2. Méthodologie de conception...............................................................................................31
3.3. Conception de chemin de données du processeur monocycle.............................................32
3.3.1 Implémentation matérielle de la Phase de recherche d’instruction (FETCH)...............32
3.3.2 Implémentation matérielle de la Phase de décodage d’instruction (DECOD)...............33
3.3.3 Implémentation matérielle de la phase d’exécution d’instruction (EXECUTE)..............33
3.3.4 Assemblage de chemin de données monocycle...........................................................38
3.4. Conception de l’unité de contrôle monocycle......................................................................38
3.4.1 Conception de l’unité principale de contrôle................................................................39
3.4.2 Conception de l’unité de contrôle de l’UAL..................................................................41
CHAPITRE IV.........................................................................................................................................43
Architecture Multi-cycle pour ISA MIPS...............................................................................................43
4.1. Objectifs...............................................................................................................................44
4.2. Caractéristiques de l’architecture multi-cycle......................................................................44
4.3. Conception de chemin de données multi-cycle....................................................................45
4.3.1 Implémentation matérielle de la phase de recherche d’instruction.............................45
4.3.2 Implémentation matérielle de la phase de décodage d’instruction.............................45
4.3.3 Implémentation matérielle de la phase d’exécution d’instruction...............................46
4.3.4 Assemblage de chemin de données multicyle..............................................................51
4.4. Conception de l’unité de contrôle multi-cycle (logique cablée et micro-séquenceur).........52
CHAPITRE V..........................................................................................................................................57
Architecture pipeline pour ISA MIPS....................................................................................................57
5.1. Objectifs...............................................................................................................................58
5.2. Caractéristiques de pipeline.................................................................................................58
5.3. Problèmes et résolutions avec Pipeline à 5 étages...............................................................61
5.4. Exemples d’aléas..................................................................................................................62
4
Table des Figures
Figure 1. Architecture des Ordinateurs...............................................................................................8
Figure 2. Démarche de Conception......................................................................................................9
Figure 3. Symboles des fonctions logiques de base.............................................................................11
Figure 4. Symboles des fonctions universelles.....................................................................................11
Figure 5. Symbole d’un décodeur 3 vers 8...........................................................................................11
Figure 6. Symbole logique d’un Multiplexeur 8 vers 1.........................................................................11
Figure 7. Symbole logique d’un Démultiplexeur 1 vers 8....................................................................12
Figure 8. Réseau logique programmable avec matrices ET et OU programmables.............................13
Figure 9. Instants de stabilité d’un circuit...........................................................................................13
Figure 10. Circuit logique d’une bistable D..........................................................................................14
Figure 11. Circuit logique d’une Bascule D...........................................................................................14
Figure 12. Symbole de banc de registres.............................................................................................14
Figure 13. Description détaillée du banc de registres..........................................................................15
Figure 14. Registre $ intégré dans le µP MIPS....................................................................................15
Figure 15. Architecture de VON NEUMANN........................................................................................16
Figure 16. Architecture de HARVARD..................................................................................................16
Figure 17. Architecture de HARVARD modifié.....................................................................................17
Figure 18. Exemple de différence entre RISC et CISC...........................................................................19
Figure 19. Emplacement de ISA........................................................................................................21
Figure 20. Hiérarchie entre le SW et HW.............................................................................................22
Figure 21. Opération add de MIPS.....................................................................................................22
Figure 22. Opérations de transfert entre la mémoire centrale et le processeur.................................24
Figure 23. Mapping de données dans la mémoire...............................................................................24
Figure 24. Exemple de différence de transfert entre MIPS et 8086.....................................................24
Figure 25. Chargement : instruction et niveau RTL..............................................................................25
Figure 26. Rangement : Instruction et niveau RTL...............................................................................25
Figure 27. Branchement si égal ; instruction et niveau RTL.................................................................25
Figure 28. Branchement si différent : instruction et niveau RTL..........................................................25
Figure 29. Format d’instruction de type R...........................................................................................26
Figure 30. Exemples de format R.........................................................................................................26
Figure 31. Format d’instruction de type I............................................................................................26
Figure 32. Format I avec LW et SW......................................................................................................26
Figure 33. Format I avec Beq et Bne....................................................................................................27
Figure 34. Format d’instruction de type J............................................................................................27
Figure 35. Instructions arithmétiques MIPS.........................................................................................28
Figure 36. Instructions logiques MIPS..................................................................................................28
Figure 37. Instructions de transfert MIPS............................................................................................29
Figure 38. Instructions de branchement MIPS....................................................................................29
Figure 39. Schéma d’exécution d’instruction pour un processeur monocycle................................32
Figure 40. Conception matérielle pour la recherche d’instruction..................................................33
Figure 41. Conception matérielle pour la phase de décodage..........................................................33
Figure 42. Conception matérielle pour exécution de type R............................................................34
Figure 43. Conception matérielle pour exécution de instruction ORI.............................................35
5
Figure 44. Conception matérielle pour l’exécution de l’instruction LW..........................................36
Figure 45. Conception matérielle pour l’exécution de l’instruction SW..........................................37
Figure 46. Conception matérielle pour l’exécution de l’instruction beq.........................................37
Figure 47. Implémentation matérielle d’un chemin de données monocycle avec unité de contrô le
.............................................................................................................................................................38
Figure 48. Schéma général de l’unité de contrô le monocycle..........................................................39
Figure 49. Schéma détaillé de l’unité de contrô le monocycle..........................................................39
Figure 50. RLP de l’unité principale de contrô le..............................................................................40
Figure 51. Multiplexeur de l’UAL monocycle....................................................................................41
Figure 52. Implémentation matérielle de la phase de recherche d’instruction...................................45
Figure 53. Implémentation matérielle de la phase de décodage........................................................46
Figure 54. Implémentation matérielle de la première étape de la phase d’exécution pour type-R....46
Figure 55. Implémentation matérielle de la deuxième étape de la phase d’exécution pour type-R.. .47
Figure 56. Implémentation matérielle de la première étape de la phase d’exécution pour ORI.........47
Figure 57. Implémentation matérielle de la deuxième étape de la phase d’exécution pour ORI........48
Figure 58. Implémentation matérielle de la première étape de la phase d’exécution pour LW..........49
Figure 59. Implémentation matérielle de la deuxième étape de la phase d’exécution pour LW.........49
Figure 60. Implémentation matérielle de la troisième étape de la phase d’exécution pour LW.........49
Figure 61. Implémentation matérielle de la première étape de la phase d’exécution pour SW.........50
Figure 62. Implémentation matérielle de la deuxième étape de la phase d’exécution pour SW........50
Figure 63. Implémentation matérielle de la phase d’exécution de Beq avec condition vérifiée....51
Figure 64. Implémentation matérielle de la phase d’exécution de J...................................................51
Figure 65. Implémentation matérielle d’un chemin de données multi-cycle avec unité de contrô le
.............................................................................................................................................................52
Figure 66. Machine à état traditionnelle de l’unité de contrôle multi-cycle........................................53
Figure 67. Logique de contrô le cablée de unité de contrô le multi-cycle.........................................54
Figure 68. Machine à état de micro-séquenceur.................................................................................55
Figure 69. Implémentation matérielle de unité de contrôle multi-cycle par micro-séquenceur.........56
Figure 70. Exemple de Lavage en pipeline...........................................................................................58
Figure 71. Chemin de données monocycle..........................................................................................59
Figure 72. Chemin de données multicycle...........................................................................................59
Figure 73. Chemin de données Pipeline..............................................................................................60
Figure 74. Approche de 5 cycles pour toutes les instructions..............................................................60
Figure 75. Représentation en pipeline en 5 étages d’exécution..........................................................61
Figure 76. Ressources matérielles pour pipeline en 5 étages..............................................................61
Figure 77. Représentation matérielle de l’exemple 1..........................................................................63
Figure 78. Solution 1 de l’exemple 1...................................................................................................63
Figure 79. Solution 2 pour l’exemple 1...............................................................................................64
Figure 80. Exemple d’aléas de données...............................................................................................65
Figure 81. Solution de l’aléa de données.............................................................................................65
6
CHAPITRE I.
Introduction à la méthodologie de
conception des architectures.
7
1.1. Objectifs
Les objectifs de ce chapitre :
Présenter les démarches de conception d’une manière générale
Présenter des rappels sur les circuits combinatoires et séquentiels
Définir quelques architectures des calculateurs et les jeux d’instructions
Présenter la méthodologie de conception des processeurs
1.2. Introduction
Contrôle E
µP
Mémoire
Chemin de
S
données
8
Il s’agit de deux démarches de conception différentes :
Top- Bottom-
Spécification Up Design
Down
Design
Conception Architecturale
Déma Déma
rche Conception Logique rche
Raffineme Abstraction
desce
nt ascen
sur un
dendant
chaque Placement/Routage dante
ensemble
de
e
constituant
constituants
Silicium
Figure 2. Démarche de Conception
Les niveaux d’abstraction lors d’une conception matérielle sont donnés par la table 1,
Nous désignons par :
Conception électrique : L’optimisation des caractéristiques électriques
Conception logique : L’optimisation des équations logiques
Conception numérique : L’optimisation des traitements
Conception architecturale : Le choix des fonctionnalités
Conception fonctionnelle : l’optimisation des implémentations matérielles et
logicielles
Conception système : L’optimisation conjointe des implémentations matérielles et
logicielles
9
Type Eléments de base Conception
10
ET : z = u1.u2=u1u2, z est vrai si u1 est vraie et u2 est vrai
OU : z = u1+u2, z est vrai lorsque u1 est vrai ou u2 est vrai, ou les deux.
NON : z = u, z est vrai si u est fausse.
Les portes logiques associées à ces opérateurs sont représentées comme suit :
Ces fonctions peuvent être réalisées par des opérateurs universels NAND e NOR,
leurs symboles sont :
Nous rappelons qu’un décodeur est un dispositif qui pour chaque combinaison des
variables d’entrée, active la sortie correspondante.
11
Figure 6. Symbole logique d’un Multiplexeur 8 vers 1
Toute fonction logique de n variables peut se mettre sous une forme de somme de
produits ou de produit de sommes. On peut donc utiliser une structure comportant
deux ensembles fonctionnels :
Un ensemble d’opérateurs ET organisé sous forme d’une matrice qui génère
les produits des variables d’entrée, éventuellement complémentées.
Un ensemble d’opérateur OU, appelé matrice OU, qui somme les produits.
La figure 8 illustre un exemple de réseau logique programmable
12
Figure 8. Réseau logique programmable avec matrices ET et OU programmables
1.5.1. Horloges
13
Figure 10. Circuit logique d’une bistable D
D D Q D Q Q
Bistable Bistable
C D C D Q Q
14
Figure 12. Symbole de banc de registres
Cette architecture inclut un seul système de stockage unique (mémoire) pour stocker
des données ainsi que le programme à exécuter. Le processeur a besoin au moins de
trois cycles d'horloge pour compléter une instruction. Dans le premier cycle d'horloge, le
processeur reçoit l'instruction de la mémoire et la décode. Dans le second cycle, les
données requises sont extraites de la mémoire. Et dans le troisième cycle, le processus
est achevé par une phase d’exécution. C'est une architecture relativement plus ancienne
et elle a été remplacée par l'architecture de Harvard (Figure 15).
L’ordinateur a deux mémoires séparées pour stocker des données et un programme d’où
existence de deux bus de données DMD et PMD (Figure …) Le processeur peut terminer
la recherche de l’instruction et de la donnée dans un cycle si des stratégies de pipeline
appropriées sont mises en œuvre (Figure 2). La plupart des architectures informatiques
modernes sont basées sur l'architecture de Harvard.
16
1.6.1.3. Architectures de HARVARD modifié
Cette architecture de HARVARD a été améliorée dans le but d’avoir plus de performance
par ajout d’un DMA pour augmenter le taux de transfert de données vers la mémoire
sans passer par le microprocesseur dans le cas de son déconnexion et aussi par l’ajout
d’une mémoire cache dont le but est stocker les informations les plus fréquemment
utilisées par les logiciels et les applications lorsqu'ils sont actifs, cette architecture est
appelée HAVAARD MODIFIE (Figure…) souvent utilisée par les microcontrô leurs.
Les performances des microprocesseurs sont définies par trois facteurs clés :
le nombre d’instructions I
le temps de cycles d’horloge T
le nombre de cycles d’horloge par instruction. C
Cette performance se calcule par : I * C* T, Les valeurs de I et C se distinguent suivant
l’architecture des jeux d’instruction, nous distinguons trois types
CISC (Complex Instruction Set Computer) : I faible, C grand
RISC (Reduce Instruction Set Computer) : I élevé, C faible
VLIW (Very Large Instruction Word) : I réduit car macro-instruction RISC, C faible
Cette dernière est une Famille d’ordinateurs dotés d’un Processeur à mot d’instruction
très long (> 128 bits) dont une instruction est équivalente à plusieurs instructions
indépendantes et les compilateurs génèrent un code en fonction des ressources
disponibles
17
1.6.2.1. Architectures de jeu d’instructions Complexes CISC
C’est une architecture avec une grande variété d’instructions où le µP doit exécuter des
tâ ches complexes par instruction unique. Pour une tâ che donnée, une machine CISC
exécute ainsi un petit nombre d’instructions mais chacune nécessite un plus grand
nombre de cycles d’horloge (Exemple:8086,68000…). Par le passé la conception de
machines CISC était la seule envisageable. En effet, vue que la mémoire travaillait très
lentement par rapport au processeur, on pensait qu’il était plus intéressant de
soumettre au microprocesseur des instructions complexes, plutô t que de coder une
opération complexe par plusieurs instructions plus petites (qui demanderaient autant
d’accès mémoire).
Comme synthèse, la différence entre ces deux architectures est présentée par le tableau
suivant
Architecture RISC Architecture CISC
18
La figure 18 illustre un exemple comparatif entre les deux architectures
Pour créer un chemin de données qui nous permet d’exécuter l’ensemble des
instructions MIPS. Nous devons respecter les étapes suivantes : Chaque instruction est
donnée en fonction des transferts des registres.
Le chemin de données doit permettre le transfert des informations
entre les registres.
Le chemin de données inclut la mémoire programme.
Le Choix d’un ensemble de composants nécessaires (UAL MUX,
Banc de Registre…) pour le chemin de données et établissement de
la méthodologie horloge.
L’assemblage des différents composants pour la satisfaction des
besoins.
La détermination les points de contrô les nécessaires pour
effectuer le transfert des registres.
L’assemblage de la logique de contrô le. (séquenceur)
19
CHAPITRE II.
Architecture de l’ensemble
d’instructions MIPS.
20
2.1 Objectifs
L’ interface clé entre les différents niveaux d’abstraction c’est l’architecture de l’ensemble
d’instructions (ISA) comme le montre la figure 18.
Cette interface suit une hiérarchie de traduction entre la conception logicielle et la conception
matérielle donnée par la figure 20
21
Figure 20. Hiérarchie entre le SW et HW
Il est évident que tout ordinateur doit être capable d’effectuer des opérations
arithmétiques, logiques, de transfert des données et de branchement suite à une
décision prise par l’unité de contrô le, à titre d’exemple, en notation MIPS, l’instruction
add permet d’additionner deux opérandes (a et b ) et mettre le résultat dans une autre
opérande (c) suivant la forme suivante (Figure 21).
22
Figure 21. Opération add de MIPS
Les opérandes des instructions arithmétiques et logiques ne peuvent pas être des
variables quelconques ; ils doivent provenir d’un nombre limité d’emplacements
particuliers appelés registres. La taille d’un registre dans l’architecture MIPS est de 32
bits possède 32 registres, notés $0, $1, ...,$31 Les registres sont plus rapide que la
mémoire. Les registres sont plus facile à utiliser pour le compilateur. Les registres
peuvent contenir des variables. Donc cela permet de réduire le trafic au niveau de la
mémoire. Ces 32 registres sont intégrés dans un banc de registres dont le schéma
synoptique est donné par la figure 13 du premier chapitre. Ces registres généraux sont
interchangeables, sauf :
le registre $0 qui vaut toujours 0, même après une écriture.
Le registre $31, utilisé implicitement par certaines instructions pour
récupérer l'adresse de retour avant un saut.
Les autres registres ont des utilisations préférentielles, mais cela n'est strict que pour
communiquer avec d'autres programmes (exemple: utiliser des programmes en
librairies). Le tableau suivant illustre le nom et utilité de chaque registre.
Numéro
Nom Usage
de $
zero 0 Zéro (toujours)
at 1 Réservé par l'assembleur
v0 .. v1 2 .. 3 Retour de valeurs
a0 .. a3 4 .. 7 Passage d'arguments
t0 .. t7 8 .. 15 Temporaires non sauvegardés
s0.. s7 16 .. 23 Temporaires sauvegardés
t8.. t9 24 .. 25 Temporaires non sauvegardés
k0.. k1 26 .. 27 Réservés par le système
gp 28 Global Pointer
sp 29 Stack Pointer
fp 30 Frame Pointeur
23
ra 31 Return Address
Tableau 3. Les registres de l’architecture MIPS
Beaucoup de programmes ont plus de variables que les machines. Par conséquent, le
compilateur cherche à conserver dans les registres les variables les plus souvent
utilisées et place le reste en mémoire. 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 comme les tableaux qui sont stockées en
mémoire. Les opérations arithmétiques n’ont lieu que dans les registres. MIPS doit donc
disposer d’instructions qui transfèrent les données entre la mémoire et les registres.
Depuis 1980 toutes les machines utilisent des adresses au niveau de l’octet (8 bits).
Avec l’architecture MIPS, on peut lire un mot de 32 bits comme 4 octets en un seul coup,
Pour le MIPS, le transfert des données se fait suivant la notion Big endian alors que pour
le 8086, il se fait en little endian comme le montre la figure 24.
24
Pour l’architecture MIPS, les instructions de transfert des mots à 32 bits sont LW et SW
(Figures 25 et 26).
Alors que les instructions de branchement conditionnel sont représentées par BEQ et
BNE. Les instructions et leurs niveaux RTL sont donnés par les figures 27 et 28.
Pour l’architecture MIPS, une instruction est représentée par un format binaire codé sur
32 bits stocké dans la mémoire, ce format est constitué de plusieurs champs incluant le
code opératoire de l’instruction, les numéros de registres source, transfert et
destination, une valeur constante, le nombre d’instructions à sauter …. Ce format va être
décodé par le séquenceur afin d’envoyer au chemin de données les signaux de contrô le
adéquats pour exécuter cette ladite instruction. Pour l’architecture MIPS, il existe 3
types de format d’instructions
Type R
Type I
Type J
25
Le format R est constitué de 6 champs. Les instructions de format R ont toutes un code-
op de 0. Ces instructions ont trois registres opérandes : rs, rt, rd. Les champs rs (registre
source) et rt (registre transfert) sont les sources et rd (registre destination) est la
destination. La fonction UAL se trouve dans le champ fonct et est décodée par le modèle
de contrô le de l'UAL de la section précédente. Les instructions de cette forme que nous
réalisons sont les instructions add, sub,or et slt (set on less than, positionner
lorsqu’inférieur). Le champ decval sera utilisé pour les décalages. Le format de type R
est donné par la figure suivante
A tire d’exemples, l’instruction add ait une fonction 32 et l’instruction sub admet une
fonction 34.
Un exemple est donné pour une instruction de chargement du registre 1 par le contenu
de la mémoire d’adresse (100 plus la valeur du registre 2).
26
Figure 32. Format I avec LW et SW
Le format de type J est constitué de deux champs (Figure …), un champs pour adresse
sur 26 bits de bit 0 au bit 25 et le reste pour le code opératoire par exemple le code
opératoire de l’instruction J est 2.
27
Figure 35. Instructions arithmétiques MIPS
28
Figure 37. Instructions de transfert MIPS
29
CHAPITRE III.
30
3.1. Objectifs
31
Le schéma d’exécution est donné par la figure 39, ca commence avec une recherche de
format d’instruction (FETCH) et la mise à jour de registre d’adresse de l’instruction
courante, par la suite une phase décodage au niveau de séquenceur (DECOD) et la
lecture des contenus des registres au niveau de chemin de données, enfin il s’agit de
l’exécution de l’instruction courante (EXECUTE) tout au long un seul cycle d’horloge
32
Figure 40. Conception matérielle pour la recherche d’instruction
Cette étape consiste à envoyer le code opératoire à l’unité de contrô le ( de bit 26 au bit
31) afin d’envoyer les signaux de contrô le au chemin de données ainsi que les numéros
de registres sources et destination pour le cas des formats R et I afin de lire les contenus
des registres sources. Cette lecture est désignée en niveau RTL par R[rs] et R[rt] (Figure
41).
33
3.3.3.1 Exécutions d’instructions de type R
Prenant l’exemple de l’instruction : add rd,rs,rt, le niveau RTL est donné par :
R[rd]<-R[rs]+R[rt]
Ainsi, Les deux éléments pour réaliser les instructions de type R comme add sont : le
banc de registres et L'UAL (Figure 42) :
Le banc de registres contient tous les registres et fournit deux ports de
lecture et un port d'écriture. Il fournit toujours en sortie le contenu des
registres correspondant aux entrées des registres de lecture, alors que les
écritures doivent être explicitement contrô lées par le signal de contrô le
d'écriture.
L'opération d’addition se fat par l'UAL. Cette opération est contrô lée par le
signal d'opération de l'UAL, large de 3 bits dans notre cas.
Dans ce cas, les signaux de contrô le sont donnés par RegWr pour valider écriture dans le
banc de registres et ALUctr pour effectuer opération demandé
34
Ainsi, nous avons besoin de plusieurs éléments pour réaliser l’instruction ORI comme
add sont : le banc de registres, L'UAL, registre d’extension par zéro et des multiplexeurs
(Figure 43) :
Le banc de registres fournit à UAL en sortie le contenu de registres rs.
La fonction OU se fait par l'UAL entre le contenu de rs et la valeur
immédiate qui a subit une extension par zéro sur 32 bits.. Cette opération
est contrô lée par le signal d'opération de l'UAL
La valeur immédiate doit avoir une taille dez 32 bits pour cela un registre
d’extension par zéro sera ajouté
Un multiplexeur sera ajouté pour la 2 éme opérande de UAL pour
sélectionner entre l’opérande de type (R(R[rt]) et celle de type I
(ZeroExt[imm16]]).
le résultat sera logé dans un registre de destination donné par la valeur de
rt, pour cela nous ajoutons un multiplexeur 2 vers 1 pour prendre en
considération entre la destination de type R (numéro de rd) et celle de
type I (numéro de rt)
2 éme exemple : pour l’instruction Lw rt, imm16(rs), le niveau RTL est donné par :
R[rt] <- Mem[R[rs] + SignExt[imm16]]
Ainsi, nous avons besoin de plusieurs éléments pour réaliser l’instruction ORI comme
add sont : le banc de registres, L'UAL, mémoire de données, registre d’extension par bit
de signe et des multiplieurs (Figure 44) :
35
Le banc de registres fournit à UAL en sortie le contenu de registres rs qui
sera utilisé pour le calcul de l’adresse
La fonction add se fait par l'UAL entre le contenu de rs et la valeur
immédiate qui a subit une extension par bit sur 32 bits.. ce résultat sera
exploité en tant que adresse pour la mémoire
Une fois adresse est calculé, le chargement se fait depuis la mémoire vers
le bac de registre
La valeur immédiate doit avoir une taille de 32 bits pour cela un registre
d’extension par bit de signe sera ajouté et qui va remplacer le précédent
registre d’extension en ajoutant une variable de commande ExtOp
Un multiplexeur déjà existant à la 2 éme opérande de UAL pour
sélectionner entre l’opérande de type (R (R[rt]) et celle de type I
(ZeroExt[imm16]]).
le résultat sera logé dans un registre de destination donné par la valeur de
rt, pour cela nous ajoutons un multiplexeur 2 vers 1 pour prendre en
considération entre la sortie de l’UAL et la donnée lue depuis la mémoire.
3 éme
exemple : pour l’instruction Sw rt, imm16 (rs), le niveau RTL est donné par :
Mem[ R[rs] + SignExt[imm16] <- R[rt]]
Par rapport à l’implémentation de la figure 44, nous ajoutons un lien entre le banc de
registres et la mémoire de données puisque il s’agit d’une phase d’écriture dans la
mémoire une fois l’adresse a été calculée par UAL (Figure 45)
36
Figure 45. Conception matérielle pour l’exécution de l’instruction SW
4 éme exemple : pour l’instruction beq rs, rt, imm16, le niveau RTL est donné par : Equal
<- R[rs] == R[rt] et if (Equal= 1) then PC <- PC + 4 + ( SignExt(imm16) x 4 ) else PC
<- PC + 4
Le terme SignExt(imm16) x 4 représente le nombre total de cases à sauter lors de
l’égalité pour atteindre le label, pour cela ,nous avons besoin de plusieurs éléments :
deux additionneurs, registre d’extension et de décalage par zéro et multiplexeur (Figure
46).
37
3.3.4 Assemblage de chemin de données monocycle
Figure 47. Implémentation matérielle d’un chemin de données monocycle avec unité de contrôle
38
Figure 48. Schéma général de l’unité de contrôle monocycle
39
Table 4. Table de vérité de l’unité principale de contrô le
Cela, nous permet de déterminer le circuit logique câ blé donné par le RLP de la figure ….
40
Il est noté que l’UAL de notre processeur monocycle inclut un multiplexeur permettant
de sélectionner les opérations suivant la variable ALUctr comme le montre la figure 51,
sa table de vérité est donnée par la table 5.
De plus, ces opérations dépondent des états de fonctions dans leurs formats
d’instructions essentiellement les 4 premiers bits de func<5..0> comme le montre la
table 6.
41
Ainsi la table de fonctionnement de l’unité de contrô le de l’UAL est donnée par la table 7.
Les trois premières lignes de cette table de vérité correspondent aux opérations
arithmétiques et logiques pour les instructions de type I et les autres pour les
instructions de type R.
Application : Déterminer les équations logiques ainsi que le circuit logique
correspondant !!!
42
CHAPITRE IV.
43
Chapitre IV : Architecture multicycle pour ISA MIPS
4.1. Objectifs
Par définition, dans un modèle à cycle unique, le cycle d’horloge doit avoir la même
durée pour toutes les instructions. Le cycle d’horloge est défini par le chemin le plus long
dans la machine. Par conséquences :
Les performances d’une mise en œuvre à cycle unique ne sont pas bonnes,
car certains types d’instruction pourraient être effectués en un cycle
d’horloge plus court.
De plus, chaque unité fonctionnelle ne peut être utilisée qu’une fois par
cycle ; par conséquent, certaines unités doivent être dupliquées, ce qui
augmente le coû t de la mise en œuvre.
Pour cela nous proposons une nouvelle architecture qui a un cycle de base plus court et
qui requièrent plusieurs cycles d’horloge par instruction. Cette technique est appelée
multi-cycle.
Cette architecture multi-cycle est caractérisée par :
Un seul espace mémoire pour les données et les instructions.
Insertion de plusieurs registres intermédiaires entres les différents blocs du
chemin de données
Ainsi, nous constatons que :
Chaque étape de l’exécution prendra un cycle d’horloge
Les exécutions seront donc exécutées en des nombres de cycles différents.
Avec une telle mise en œuvre, une unité fonctionnelle peut être utilisée plusieurs
fois par instruction, tant qu’il s’agit de cycles d’horloge différents. Ceci réduit la
quantité de matériel nécessaire.
44
Chapitre IV : Architecture multicycle pour ISA MIPS
Pour la phase de recherche d’instruction, nous passons par deux étapes au moment du
front du premier cycle de l’horloge
Etape 1 : chargement de format d’instruction dans le registre temporaire IR à partir
d’une mémoire centrale.
Etape 2 : mise à jour de la valeur d’adresse du registre PC par la valeur PC+4, Pour cela
nous exploitons UAL pour effectuer opération d’addition en ajoutons des multiplexeurs
Le niveau RTL est : IR ← MEM[PC] et PC ← PC + 4. L’implémentation matérielle de la
phase de recherche d’instruction est donnée par la figure 52.
Durant le deuxième cycle d’horloge, cette étape consiste à envoyer les numéros de
registres sources depuis le registre d’instruction IR vers le banc de registres pour le cas
des formats R et I afin de lire les contenus des registres sources et les sauvegarder
45
Chapitre IV : Architecture multicycle pour ISA MIPS
momentanément dans les registres A et B Le niveau RTL est donné par : A ← R[rs] et
B ← R[rt]. L’implémentation matérielle de cette phase de décodage est donnée par la
figure 53.
Figure 54. Implémentation matérielle de la première étape de la phase d’exécution pour type-R
En second lieu de cette phase d’exécution, le résultat enregistré dans ALUOut sera
transféré vers la banc de registres dont le numéro de registre de destination est envoyé
par le registre IR. Le niveau RTL est donné par : R[rd] ← ALUOut.
46
Chapitre IV : Architecture multicycle pour ISA MIPS
Figure 55. Implémentation matérielle de la deuxième étape de la phase d’exécution pour type-R
Figure 56. Implémentation matérielle de la première étape de la phase d’exécution pour ORI
47
Chapitre IV : Architecture multicycle pour ISA MIPS
Durant le deuxième cycle de la phase d’exécution, le résultat sera transféré vers la banc
de registres dont le numéro de registre de destination est donné par la valeur de rt
depuis le registre IR. Le niveau RTL de cette étape est : R[rt] ← ALUOut.
Figure 57. Implémentation matérielle de la deuxième étape de la phase d’exécution pour ORI
2 éme exemple : pour l’instruction Lw rt, imm16(rs), elle nécessité trois cycles d’horloge
pour achever la phase d’exécution. En premier cycle, elle déterminer l’adresse du mot à
transférer, le niveau RTL correspondant est donné par :ALUOut ← R[rs] +
SignExt[imm16]. Par la suite, en deuxième cycle d’horloge, le registre MDR lit le mot
depuis la mémoire centrale une fois l’adresse est sélectionnée ; le niveau RTL de cette
étape est : MDR ← Mem[R[rs] + SignExt[imm16]]. Enfin, lors de troisième cycle
d’horloge, le mot sera transféré au banc de registres dans le registre destination dont le
numéro de registre de destination est donné par la valeur de rt depuis le registre IR. Le
niveau RTL est : R[rt] ← MDR. Les figures 58, 59 et 60 illustrent respectivement les
implémentations matérielles des trois étapes de la phase d’exécution de l’instruction
LW.
48
Chapitre IV : Architecture multicycle pour ISA MIPS
3 éme
exemple : pour l’instruction Sw rt, imm16 (rs), elle necessite deux cycles
d’horloge pour acehver la phase d’éxécution. En premier elle déterminer l’adresse du
mot à transférer, le niveau RTL correspondant est donné par : ALUOut ← R[rs] +
49
Chapitre IV : Architecture multicycle pour ISA MIPS
éme
4 exemple : pour l’instruction beq rs, rt, imm16, elle necessité un seul cycle
d’horloge pour achever la phase d’exécution. le niveau RTL est donné par : ZERO ←
R[rs] == R[rt] et if (R[rs] = R[rt]) then PC ← PC + 4 + ( SignExt(imm16) x 4 ) else
PC ← PC + 4. Le ZERO est un flag de l’UAL indiquant la présence d’un résultat nul lors
de la comparaison entre les deux registres rs et rt. La figure 63 illustre l’implémentation
matérielle de l’exécution de l’instruction beq une fois la condition d’égalité est validée
entre rs et rt.
50
Chapitre IV : Architecture multicycle pour ISA MIPS
51
Chapitre IV : Architecture multicycle pour ISA MIPS
données est contrô lé par des signaux générés par une unité de contrô le. La conception
de l’unité de contrô le multi-cycle est l’objet de partie suivante.
PCWriteCond PCSource
PCWrite
ALUOp
IorD Outputs
ALUSrcB
MemRead
ALUSrcA
MemWrite Control
RegWrite
MemtoReg
Op RegDst
IRWrite [5– 0]
0
M
Jump 1 u
Instruction [25– 0] 26 28 address [31-0] x
Shift
2
left 2
Instruction
[31-26] PC [31-28]
PC 0 0
M Instruction Read
[25– 21] register 1 M
u Address u
x Read x
Instruction Read A Zero
1 Memory
[20– 16] register 2 data 1 1
MemData 0 ALU ALU ALUOut
Registers
Instruction M Write Read result
[15– 0] register data 2 B
Instruction u 0
Write Instruction [15– 11] x 4 1 M
data Write
register 1 data u
2 x
Instruction 0 3
[15– 0] M
u
x
Memory 1
data 16 32 ALU
Sign Shift
register control
extend left 2
Instruction [5– 0]
Figure 65. Implémentation matérielle d’un chemin de données multi-cycle avec unité de contrôle
52
Chapitre IV : Architecture multicycle pour ISA MIPS
Table 8. Table de vérité des signaux de contrô le pour une architecture multi-cycle
Cette table de vérité peut être remplacée par une machine à état traditionnelle
mentionnant le passage d’un état à un autre par le biais d’un compteur de 0 à 13 pour
chaque type d’instruction.
53
Chapitre IV : Architecture multicycle pour ISA MIPS
L’unité de contrô le peut être implémentée suivant une logique cablée dont Le registre
d’instruction IR envoie à unité de contrô le le code opératoire de chaque instruction et le
registre d’état fait la mise à jour de l’état présent de l’instruction courante.
54
Chapitre IV : Architecture multicycle pour ISA MIPS
Table 9. Table de vérité des signaux de contrô le pour une architecture multi-cycle
55
Chapitre IV : Architecture multicycle pour ISA MIPS
56
CHAPITRE V.
57
Chapitre V : Architecture Pipeline pour ISA MIPS
5.1. Objectifs
58
Chapitre V : Architecture Pipeline pour ISA MIPS
Nous retenons de ces deux architectures leurs avantages à savoir utiliser deux mémoires
et deux additionneurs ( monocycle) et utiliser des registres temporaires pour les
données (multicycle). Ainsi l’architecture pipeline pour implémentation des instructions
MIPS est donnée par la figure 73
59
Chapitre V : Architecture Pipeline pour ISA MIPS
De plus, nous retenons l’approche que toutes les instructions MIPS aient le même
nombre d’étage (5 cycles) comme c’est le cas pour l’instructions LW (Figure 74)
60
Chapitre V : Architecture Pipeline pour ISA MIPS
Les ressources disponibles pour ces étages sont données par la figure 76
ALU
Im Reg Dm Reg
61
Chapitre V : Architecture Pipeline pour ISA MIPS
62
Chapitre V : Architecture Pipeline pour ISA MIPS
1 solution par Suspension: possibilité de prendre la décision après 2 cycles par ajout de
hardwares : attendre jusqu’à ce que la décision puisse être prise.
63
Chapitre V : Architecture Pipeline pour ISA MIPS
Beq
And
or
Xor
Figure 79. Solution 2 pour l’exemple 1
64
Chapitre V : Architecture Pipeline pour ISA MIPS
65
Références Bibliographiques
[1] J. L. Hennessy and D. A. Patterson, Architecture des ordinateurs, Dunod, Paris 1996.
[4] C.Jrad, D Mezghani, L.Latrach, L.karia, I.Abdsslem, notes de cours sur la méthodologie de
conception des processeur, ENSI, 2014
66