Beruflich Dokumente
Kultur Dokumente
Support de Cours
Section : INGTA
Niveau : 2 année
1
Avant Propos
Les objectifs de ce cours, intitulé « Architectures 2 » destiné pour la section Ingénieur,
sont de :
Concevoir et définir l’architecture de l’ensemble des instructions (ISA).
Se familiariser avec les opérations au niveau transfert registres.
Organiser le matériel en tant que chemin de données et unité de contrô le.
Assembler des composants pour la construction des différents types de chemins
de données du processeur.
Présenter les différents types de conception d’unité de contrô le
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..................................................................40
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......................................................................................................27
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 Ent
µ rée
P Mémoire s
Chemin de So
données rtie
s
Figure 1. Architecture des Ordinateurs
8
Démarche Ascendante : connue par le nom « Bottom-up Design » c’est uns
abstraction sur l’ensemble des constituants comme le montre la figure 2
Top- Bottom-
Down Spécification Up Design
Design
Conception Architecturale
Déma Déma
rche Conception Logique rche
Raffineme Abstraction
desce
nt ascen
sur un
dendant
chaque Placement/Routage dante
ensemble
constituant de
e 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
Figure 3. Symboles des fonctions logiques de base
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
1.4.4. Les démultiplexeurs
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
1.5. Rappel sur la logique séquentielle
1.5.1. Horloges
13
D DBistab Q DBistab Q Q
C le D C le D Q Q
C
Figure 11. Circuit logique d’une Bascule D
14
Figure 13. Description détaillée du banc de registres
15
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
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
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
Figure 18. Exemple de différence entre RISC et CISC
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
Les autres instructions arithmétiques, logiques et de branchement seront présentées
explicitement à la fin de ce chapitre.
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
ra 31 Return Address
Tableau 3. Les registres de l’architecture MIPS
23
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.
Pour l’architecture MIPS, les instructions de transfert des mots à 32 bits sont LW et SW
(Figures 25 et 26).
24
Figure 25. Chargement : instruction et niveau RTL
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
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
25
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
Le format d'instruction pour le branchement si égal (code-op=4) , si non égal (code-
op=5). Les registres rs et rt sont les registres source dont on teste l'égalité. Le champ
d'adresse 16 bits, décalé, est ajouté au CP pour calculer l'adresse de destination du
branchement.
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.
2. Instructions MIPS
Les instructions MIPS sont réparties en 4 catégories
27
Figure 35. Instructions arithmétiques MIPS
28
Figure 37. Instructions de transfert MIPS
29
CHAPITRE III.
Conception de l’architecture
Mono-cycle pour ISA MIPS
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.
éme
3 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.
Ainsi la table de fonctionnement de l’unité de contrô le de l’UAL est donnée par la table 7.
41
ALUop func Operation ALUctr
bit<2>bit<1>bit<0>bit<3>bit<2>bit<1>bit<0> ALU bit<2>bit<1>bit<0>
0 0 0 x x x x Add 0 1 0
0 0 1 x x x x Sub 1 1 0
0 1 0 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
Table 7. Table de vérité de l’unité de contrô le de l’UAL
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.
Conception de l’architecture
Multi-cycle pour ISA MIPS
43
Chapitre IV : Architecture multicycle pour ISA MIPS
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.
44
Chapitre IV : Architecture multicycle pour ISA MIPS
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.
Pour la phase de recherche d’instruction, nous passons par deux étapes au moment du
front du premier cycle de l’horloge
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
45
Chapitre IV : Architecture multicycle pour ISA MIPS
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
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.
46
Chapitre IV : Architecture multicycle pour ISA MIPS
Cette phase nécessite deux cycles d’horloge, en premier temps l’UAL effectue opération
demandée par instruction entre les opérandes lues des registres A et B et loge le résultat
dans le registre ALUout. Le niveau RTL est ALUOut ←A op B, l’implémentation matérielle de
cette étape est donnée par la figure 54
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.
Figure 55. Implémentation matérielle de la deuxième étape de la phase d’exécution pour type-R
47
Chapitre IV : Architecture multicycle pour ISA MIPS
1 er exemple : pour l’instruction ORi rt, rs, imm16, elle nécessité deux cycles d’horloge
pour la phase d’écution, en premier temps la fonction OU se fait par l'UAL entre le
contenu de rs et la valeur immédiate depuis les registre IR qui a subit une extension par
zéro sur 32 bits. Le résultat sera logé dans le registre ALUOut. le niveau RTL
correspondant est donné par : ALUOut ← R[rs] OR ZeroExt[imm16]].
L’implémentation matérielle de cette première étape d’exécution est donnée par la
figure 56.
Figure 56. Implémentation matérielle de la première étape de la phase d’exécution pour ORI
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.
48
Chapitre IV : Architecture multicycle pour ISA MIPS
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.
49
Chapitre IV : Architecture multicycle pour ISA MIPS
éme
3 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] +
SignExt[imm16]. Et en deuxième cycle, le contenu de registre rt sera transféré vers la
mémoire centrale, le niveau RTL correspondant est : Mem[R[rs] + SignExt[imm16]] ←
R[rt]. Les implémentations matérielles sont données par les figures 61 et 62.
50
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.
51
Chapitre IV : Architecture multicycle pour ISA MIPS
Nous intéressons à l’instruction jump, le niveau RTL est donné par : PC ← PC [31-28] II
(IR[25-0]<<2). La figure 64 illustre l’implémentation matérielle de la phase d’exécution
de l’instruction J.
52
Chapitre IV : Architecture multicycle pour ISA MIPS
PCWriteCond PCSource
PCWrite
ALUOp
IorD Outputs
ALUSrcB
MemRead
Control ALUSrcA
MemWrite
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
La table de vérité des signaux de contrô le pour une architecture multi-cycle est donné
par le tableau suivant (travail à compléter)
53
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.
54
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.
55
Chapitre IV : Architecture multicycle pour ISA MIPS
Pour cela nous proposons une amélioration au niveau de la table de vérité précédente
qui devient comme suit (A compléter)
56
Chapitre IV : Architecture multicycle pour ISA MIPS
Table 9. Table de vérité des signaux de contrô le pour une architecture multi-cycle
57
Chapitre IV : Architecture multicycle pour ISA MIPS
58
Chapitre IV : Architecture multicycle pour ISA MIPS
59
CHAPITRE V.
Conception de l’architecture
pipeline pour ISA MIPS
60
Chapitre V : Architecture Pipeline pour ISA MIPS
1. Objectifs
61
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
62
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)
63
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
64
Chapitre V : Architecture Pipeline pour ISA MIPS
4. Exemples d’aléas
Exemple 1 : aléas de contrô le
Soit le programme suivant
65
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.
66
Chapitre V : Architecture Pipeline pour ISA MIPS
Beq
And
or
Xor
Figure 79. Solution 2 pour l’exemple 1
67
Chapitre V : Architecture Pipeline pour ISA MIPS
68
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
69