Vous êtes sur la page 1sur 69

ARCHITECTURES 2

Support de Cours
Section : INGTA
Niveau : 2 année

Enseignant Responsable : Dr Dhafer MEZGHANI

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

Nous associons à ce support de cours, un fascicule des travaux dirigés munis de


quelques éléments de correction qui permet d'appliquer les connaissances apprises
pendant les séances de cours et  d’assimiler le concept d’implémentation matérielle des
différentes architectures avant la phase de prototypage et simulation.

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

D’une manière générale, l’organisation d’un ordinateur est donné par un


microprocesseur, une mémoire centrale et des périphériques entrées/ sorties (figure 1)

Contrôle Ent
µ rée
P Mémoire s
Chemin de So
données rtie
s
Figure 1. Architecture des Ordinateurs

Nous décomposons le µP en un chemin pour véhiculer les données et une unité de


contrô le pour donner des commandes afin de satisfaire le fonctionnement du système
complet. (Figure 1)

1.3. Démarche de conception

Il s’agit de deux démarches de conception différentes :

 Démarche Descendante : connue par le nom « Top-Down Design » qui consiste à


un raffinement de chaque constituant depuis la spécification des besoins jusqu’à
couche silicium

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

Composant Conception électrique


s discrets

SSI Conception logique

MSI Conception numérique

LSI Conception architecturale

VLSI Conception fonctionnelle

ULSI Conception système

Table 1 Niveaux d’abstraction pour une conception matérielle

1.4. Rappels sur la logique combinatoire

1.4.1. Fonctions Logiques

Nous rappelons que :


 Les variables d’entrées sont des variables logiques indépendantes
 Les variables de sorties sont des variables contenant l’état de la fonction après
évaluation des opérateurs logiques sur les variables d’entrées.
 Les Opérateurs logiques de base sont :
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 :

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 :

Figure 4. Symboles des fonctions universelles

1.4.2. Les décodeurs : (n entrées, 2n sorties)

Nous rappelons qu’un décodeur est un dispositif qui pour chaque combinaison des
variables d’entrée, active la sortie correspondante.

Figure 5. Symbole d’un décodeur 3 vers 8

1.4.3. Les multiplexeurs 

Un multiplexeur est un circuit à 2n entrées d’information (D0, D1…), n entrées


d’adresse A, B… et une sortie S. Les entrées d’adresse permettent la sélection d’une
entrée d’information pour transmettre son état à la sortie S.

Figure 6. Symbole logique d’un Multiplexeur 8 vers 1

11
1.4.4. Les démultiplexeurs 

Un démultiplexeur distribue l’information d’entrée D vers l’une des 2n sorties (S0,S1…),


la sélection de la sortie concernée étant effectuée par n variables d’adresse. Il est
schématisé ainsi :

Figure 7. Symbole logique d’un Démultiplexeur 1 vers 8

1.4.5. Les réseaux logiques combinatoires

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

Figure 8. Réseau logique programmable avec matrices ET et OU programmables

12
1.5. Rappel sur la logique séquentielle

1.5.1. Horloges

La Synchronisation par horloge permet de 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
peuvent être un front ou un niveau comme le montre la figure 9

Figure 9. Instants de stabilité d’un circuit

Il existe deux types de synchronisation avec horloge :

 Synchronisation par niveau (haut ou bas)

 Synchronisation par front (montant ou descendent)

1.5.2. Bascule – bistable (synchrone)

La différence entre bistable et bascule est au moment où l’horloge provoque le


changement d’état actif, en effet pour :
 La bistable synchrone est caractérisée par un état modifié à chaque fois que
les entrées changent et que l’horloge est à 1)

Figure 10. Circuit logique d’une bistable D

Lorsque l’Horloge C = 1 Þ nouvelle valeur de D remplace l’ancienne valeur


 La bascule synchrone est caractérisée par un état n’est modifié que sur un
front d’impulsion de l’horloge)

13
D DBistab Q DBistab Q Q
C le D C le D Q Q
C
Figure 11. Circuit logique d’une Bascule D

1.5.3. Banc de registres

Pour la construction du chemin de données, il est primordial d’utiliser un BANC DE


REGISTRES comportant au moins un décodeur pour chaque port de lecture ou écriture
et un ensemble de registres construits avec des bascules D. le schéma bloc de ce banc de
registres est donné par la figure 12.

Figure 12. Symbole de banc de registres

La description détaillée du banc de registres met en évidence un décodeur, un


ensemble de registres à chargement parallèle, des multiplexeurs et des signaux de
contrô le (Figure 13)

14
Figure 13. Description détaillée du banc de registres

Chaque registre $ est constitué d’un ensemble de bascules D précédés par


multiplexeur à une entrée de commande C et le changement d’état est cadencé par le
front montant de l’horloge CLK

Figure 14. Registre $ intégré dans le µP MIPS

1.6. Théorie des architectures

1.6.1. Architectures des calculateurs

Il existe essentiellement deux types d'architectures de calculateur. Le premier s'appelle


l'architecture de Von Neumann et plus tard l'architecture de Harvard a été adoptée pour
concevoir des ordinateurs numériques.

1.6.1.1. Architecture de VON NEUMANN

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

Figure 15. Architecture de VON NEUMANN

1.6.1.2. Architecture de HARVARD 

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.

Figure 16. Architecture de HARVARD

1.6.1.3. Architectures de HARVARD modifié 

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.

Figure 17. Architecture de HARVARD modifié

1.6.2. Architectures de jeux d’instructions ISA

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

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

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

1.6.2.2. Architectures de jeu d’instructions réduites RISC


Des études statistiques menées au cours des années 70 ont montré que les programmes
générés par les compilateurs se contentaient le plus souvent d'affectations, d'additions
et de multiplications par des constantes. Les instructions complexes doivent être
réalisées à partir de séquences basées sur les instructions élémentaires, ce qui
nécessite un compilateur très évolué dans le cas de programmation en langage de haut
niveau (Exemple : MIPS,SPARC…).

1.6.2.3. Synthèse entre RISC et CISC

Comme synthèse, la différence entre ces deux architectures est présentée par le tableau
suivant
Architecture RISC Architecture CISC

 instructions simples ne prenant  instructions complexes prenant


qu’un seul cycle plusieurs cycles
 instructions au format fixe  instructions au format variable
 décodeur simple (câ blé)  décodeur complexe
 beaucoup de registres (microcode)
 seules les instructions LOAD et  peu de registres
STORE ont accès à la mémoire  toutes les instructions sont
 peu de modes d’adressage susceptibles d’accéder à la
 compilateur complexe mémoire
 beaucoup de modes d’adressage
 compilateur simple
Tableau 2 : Différence entre RISC et CISC

La figure 18 illustre un exemple comparatif entre les deux architectures

18
Figure 18. Exemple de différence entre RISC et CISC

Dans ce que se suit, nous intéressons à l’ensemble de jeu d’instruction MIPS.

1.7. Processus de conception des processeurs pour jeu d’instructions


MIPS

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

Les objectifs de ce chapitre :


 Identifier l’interface (la relation) entre le logiciel de plus bas niveau (langage machine) et
le matériel.
 classer les jeux d’instructions
 Identifier les opérations du matériel de l’ordinateur
 Identifier les opérandes du matériel de l’ordinateur
 Représenter l’instruction en format d’instruction

2.2 Problématique de conception des systèmes informatiques

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.

Figure 19. Emplacement de ISA

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

Généralement, les concepteurs des systèmes informatiques ont un but commun :


trouver un langage qui rend plus aisée la construction du matériel et du compilateur
tout en maximisant les performances et en minimisant le coû t.

2.3 Jeu d’instructions MIPS

Pour le language machine, nous devons connaitre


 Les opérations du matériel de l’ordinateur
 Les opérandes du matériel de l’ordinateur
 La représentation des instructions dans l’ordinateur (Format d’instruction)

1. Opérations du matériel de l’ordinateur

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

Figure 21. Opération add de MIPS

22
Les autres instructions arithmétiques, logiques et de branchement seront présentées
explicitement à la fin de ce chapitre.

2. Opérandes du matériel de l’ordinateur

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.

Figure 22. Opérations de transfert entre la mémoire centrale et le processeur

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,

Figure 23. Mapping de données dans la mémoire

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.

Figure 24. Exemple de différence de transfert entre MIPS et 8086

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

Figure 26. Rangement : 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.

Figure 27. Branchement si égal ; instruction et niveau RTL

Figure 28. Branchement si différent : instruction et niveau RTL

2.4 Représentation des instructions

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

1. Représentation d’instructions de Type R

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

Figure 29. Format d’instruction de type R

A tire d’exemples, l’instruction add ait une fonction 32 et l’instruction sub admet une
fonction 34.

Figure 30. Exemples de format R

Ce type de format est constitué de 4 champs. Le format d'instruction pour les


instructions de chargement (code-op=35) et de rangement (code-op=43). Le registre rs
est le registre de base ajouté au champ d'adresse 16 bits pour former l'adresse mémoire.
Pour les chargements, rt est le registre destination de la valeur chargée. Pour les
rangements, rt est le registre source dont la valeur doit être stockée en mémoire.

Figure 31. Format d’instruction de type I

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

Figure 32. Format I avec LW et SW

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.

Figure 33. Format I avec Beq et Bne

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.

Figure 34. Format d’instruction de type J

2. Instructions MIPS
Les instructions MIPS sont réparties en 4 catégories

 Arithmétiques (Figure 35)


 Logiques (Figure 36)
 Transfert (Figure 37)
 Branchement (Figure 38)

27
Figure 35. Instructions arithmétiques MIPS

Figure 36. Instructions logiques MIPS

28
Figure 37. Instructions de transfert MIPS

Figure 38. Instructions de branchement MIPS

29
CHAPITRE III.

Conception de l’architecture
Mono-cycle pour ISA MIPS

30
3.1. Objectifs

L’objectif de ce chapitre est :


 Concevoir un chemin de données monocycle
 Définir les signaux de contrô le
 Concevoir une unité de contrô le monocycle suivant une logique cablée

3.2. Méthodologie de conception

Le processeur monocycle est caractérisé par :


 Un seul cycle d’horloge par instruction incluant les étapes de recherche
d’instruction, de décodage et d’exécution donc CPI = 1
 Un temps d’exécution très long par rapport aux autres types de processeurs
comme multi-cycle et pipline
De plus, l’architecture de jeu d’instructions, présentée dans le chapitre II, définit
plusieurs aspects de mise en œuvre lors de la conception de son chemin de données.
Pour cela nous devons respecter les étapes suivantes :
 A partir de l’instruction et de sa description, nous définissons le transfert des
registres, de plus le chemin de données doit contenir une mémoire de
programme
 Nous identifions les matériels nécessaires pour le datapath (UAL, Banc de
registres, Multiplexeurs…)
 Nous assemblons les éléments pour satisfaire le besoin
 Nous déterminons les signaux de contrô le nécessaires pour effectuer le transfert
au niveau des registres
 Nous assemblons la logique de contrô le (séquenceur)
Dans ce qui se suit, nous concevons un chemin de données pour l’exécution de quelques
instructions MIPS suivantes :
Chargement et rangement : LW et SW
Arithmétiques et logiques : ADD, addu, sub, subu, and, or, xor, nor, slt et sltu
Arithmétiques et logiques  immédiats: ADDi, andi, ori, xori, nori, slti et sltiu
Branchement : Beq, Bne et J

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

Figure 39. Schéma d’exécution d’instruction pour un processeur monocycle

3.3. Conception de chemin de données du processeur monocycle

3.3.1 Implémentation matérielle de la Phase de recherche d’instruction (FETCH)

Au moment du front de l’horloge, cette phase passe par deux étapes :


Etape 1 : lire le format d’instruction logée dans la mémoire de programme
correspondant à une valeur d’adresse courante de PC (Counter Program). Pour cela,
nous avons besoin d’une mémoire de programme de type ROM
Etape 2 : faire la mise à jour de la valeur d’adresse PC afin de préparer l’instruction
suivante une fois l’instruction courante vient d’être achévée.la mise à jour se fait par une
incrémentation de 4 octets de la valeur d’adresse. Pour cela nous avons besoin d’un
registre à chargement et un additionneur.
La conception matérielle pour cette phase Fetch est donnée par la figure 40.

32
Figure 40. Conception matérielle pour la recherche d’instruction

3.3.2 Implémentation matérielle de la Phase de décodage d’instruction (DECOD)

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

Figure 41. Conception matérielle pour la phase de décodage

3.3.3 Implémentation matérielle de la phase d’exécution d’instruction


(EXECUTE)

Dans cette partie, nous s’intéressons essentiellement à l’exécution des instructions de


type R et de type I.

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.

Figure 42. Conception matérielle pour exécution de type R

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é

3.3.3.2 Exécutions d’instructions de type I

Dans cette partie, nous traitons 4 exemples :


1 er exemple : pour l’instruction ORi rt, rs, imm16, le niveau RTL est donné par :
R[rt] <- R[rs] OR ZeroExt[imm16]]

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)

Figure 43. Conception matérielle pour exécution de instruction ORI

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.

Figure 44. Conception matérielle pour l’exécution de l’instruction LW

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

Figure 46. Conception matérielle pour l’exécution de l’instruction beq

37
3.3.4 Assemblage de chemin de données monocycle

En tenant compte de tout ce qu’il a été présenté précédemment, nous obtenons le


chemin de données d’un processeur monocycle donné par la figure 47. Ce chemin de
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 monocycle est l’objet de partie suivante.

Figure 47. Implémentation matérielle d’un chemin de données monocycle avec unité de contrôle

3.4. Conception de l’unité de contrôle monocycle

Le schéma synoptique de l’unité contrô le du processeur monocycle est donné par la


figure 48 les signaux de contrô le (RegDest, Wr…) seront déterminés à partir des états
binaires du code opératoire I[31…26] et les fonctions des instructions I[5..0]

38
Figure 48. Schéma général de l’unité de contrôle monocycle

Puisque les opérations arithmétiques et logiques se différentient suivant le type


d’instruction (Type R ou type I), nous partageons l’unité de la figure 48 en deux blocs :
 Unité Principale : qui génère les signaux de contrô le de tous les blocs de chemins
de données à l’exception d’UAL
 ALU contrô le : qui génère les signaux de contrô le de l’UAL (ALUctr) suivant les
états de la fonction (func) et opération à effectuer(ALUop).
Cette partition est donnée par la figure 49

Figure 49. Schéma détaillé de l’unité de contrôle monocycle

1. Conception de l’unité principale de contrôle

A partir de conception de chemin de données du processeur monocycle et les nveaux


RTL présentés pour quelques instructions de base MIPS, nous dressons la table de vérité
de l’unité principale de contrô le donnée par la table suivante.

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

Figure 50. RLP de l’unité principale de contrôle

2. Conception de l’unité de contrôle de l’UAL

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.

Figure 51. Multiplexeur de l’UAL monocycle

Table 5. Table de vérité de Multiplexeur

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.

Table 6. Opération effectuée suivant la fonction

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

L’objectif de ce chapitre est :

 Concevoir un chemin de données multi-cycle


 Définir les signaux de contrô le
 Concevoir une unité de contrô le multi-cycle suivant une machine à états

2. Caractéristiques de l’architecture multi-cycle

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.

44
Chapitre IV : Architecture multicycle pour ISA MIPS

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

3. Conception de chemin de données multi-cycle

Pour le cas de l’architecture multi-cycle, nous devons passer par la conception de 5


phases afin d’élaborer architecture finale de notre processeur multi-cycle

1. Implémentation matérielle de la phase de recherche d’instruction

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

45
Chapitre IV : Architecture multicycle pour ISA MIPS

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.

Figure 52. Implémentation matérielle de la phase de recherche d’instruction.

2. Implémentation matérielle de la phase de décodage d’instruction

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

Figure 53. Implémentation matérielle de la phase de décodage

3. Implémentation matérielle de la phase d’exécution d’instruction


Dans cette partie le nombre de cycle d’horloge se diffère d’une instruction à une autre.

4.3.3.1 Exécutions d’instructions de type-R

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

4.3.3.2 Exécutions d’instruction de type I

Dans cette partie, nous traitons 4 exemples :

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

Figure 58. Implémentation matérielle de la première étape de la phase d’exécution pour LW

Figure 59. Implémentation matérielle de la deuxième étape de la phase d’exécution pour LW

Figure 60. Implémentation matérielle de la troisième étape de la phase d’exécution pour LW

é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

Figure 61. Implémentation matérielle de la première étape de la phase d’exécution pour SW

Figure 62. Implémentation matérielle de la deuxième étape de la phase d’exécution pour SW

é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

Figure 63. Implémentation matérielle de la phase d’exécution de Beq avec condition


vérifiée.

4.3.3.3 Exécutions d’instructions de type-J

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.

Figure 64. Implémentation matérielle de la phase d’exécution de J

4. Assemblage de chemin de données multicyle.

52
Chapitre IV : Architecture multicycle pour ISA MIPS

En tenant compte de tout ce qu’il a été présenté précédemment, nous obtenons le


chemin de données d’un processeur multi-cycle donné par la figure 65. Ce chemin de
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
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

4. Conception de l’unité de contrôle multi-cycle (logique cablée et micro-


séquenceur)

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

Figure 66. Machine à état traditionnelle de l’unité de contrôle multi-cycle

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

Figure 67. Logique de contrôle cablée de unité de contrôle multi-cycle

Le passage d’un état à un autre peut être :

 Une incrémentation d’état


 Un chargement de code opératoire
 Retour à zéro

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

Ainsi la machine à état traditionnel sera donnée par la figure 68.

57
Chapitre IV : Architecture multicycle pour ISA MIPS

Figure 68. Machine à état de micro-séquenceur

Ainsi l’implémentation de la logique de contrô le pour une architecture multi-cycle peut


être améliorée par un micro-séquenceur en utilisant :

 Une mémoire morte ROM pour les différents signaux de contrô le


 Un compteur pour cadencer l’envoie des signaux de contrô le tout dépond des
états des variables Z, I, C et l’état présent de la machine envoyé par un
transcodeur de code opératoire.

L’implémentation matérielle de micro-séquenceur pour une architecture multi-cycle est


donnée par la figure 69.

58
Chapitre IV : Architecture multicycle pour ISA MIPS

Figure 69. Implémentation matérielle de unité de contrôle multi-cycle par micro-séquenceur

59
CHAPITRE V.

Conception de l’architecture
pipeline pour ISA MIPS

60
Chapitre V : Architecture Pipeline pour ISA MIPS

1. Objectifs

L’objectif de ce chapitre est :


 Concevoir un chemin de données pipeline
 Résoudre les problèmes d’aléas par plusieurs techniques
2. Caractéristiques de pipeline
 La technique du pipeline est une technique de mise en œuvre qui permet à
plusieurs instructions de se chevaucher pendant l'exécution.
 Une instruction est découpée dans un pipeline en petits morceaux appelés étage
de pipeline.
 La technique du pipeline améliore le débit des instructions plutô t que le temps
d'exécution de chaque instruction.
 La technique du pipeline exploite le parallélisme entre instructions d’un flot
séquentiel d’instructions.
 La figure70 illustre un exemple de lavage (lavage, séchage, repassage et
rangement) en mode pipeline

Figure 70. Exemple de Lavage en pipeline

Nous rappelons les chemins de données d’architectures monocycle et multi-cycle


donnés respectivement par les figures 71 et 72.

61
Chapitre V : Architecture Pipeline pour ISA MIPS

Figure 71. Chemin de données monocycle

Figure 72. Chemin de données multicycle

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

Figure 73. Chemin de données Pipeline

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)

Figure 74. Approche de 5 cycles pour toutes les instructions

Ainsi la représentation d’exécution en pipeline à 5 étages pour plusieurs instructions est


donnée par la figure 75.

63
Chapitre V : Architecture Pipeline pour ISA MIPS

Figure 75. Représentation en pipeline en 5 étages d’exécution

Les ressources disponibles pour ces étages sont données par la figure 76
ALU

Im Reg Dm Reg

Figure 76. Ressources matérielles pour pipeline en 5 étages

3. Problèmes et résolutions avec Pipeline à 5 étages

Il existe deux Types d’aléas (« hazards ») :

64
Chapitre V : Architecture Pipeline pour ISA MIPS

 Aléas de contrô le: prendre décision avant d’évaluer la condition dans le


cas d’une instruction de saut conditionnel, la Résolution se fait par
suspension (attente) - par prédiction (correcteur)
 Aléas de données: utilisation d’une donnée avant qu’elle soit prête ,
instruction dépend des résultats d ’une instruction antérieure encore
dans le pipeline. La Résolution se fait par suspension (attente) ou bien
résolus par renvoi (envoyer l’information d’un étage à un autre)
 Aléas de structure: utilisation d’une même ressource plusieurs fois en
même temps. La résolution: par suspension (attente) ou ajout d’étape

4. Exemples d’aléas
Exemple 1 : aléas de contrô le
Soit le programme suivant

Si la condition est vérifiée le problème se situe au niveau de l’exécution des instructions


and, or et sub qui viennent de commencer à être exécuter : perte de temps
La représentation par ressources matérielles est donnée par la figure 77.

65
Chapitre V : Architecture Pipeline pour ISA MIPS

Figure 77. Représentation matérielle de l’exemple 1

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.

Figure 78. Solution 1 de l’exemple 1

2éme Solution: par Prédiction

66
Chapitre V : Architecture Pipeline pour ISA MIPS

Beq
And

or

Xor
Figure 79. Solution 2 pour l’exemple 1

Exemple 2 : Aléas de données

Le problème est la dépendance en arrière de la donnée r1

67
Chapitre V : Architecture Pipeline pour ISA MIPS

Figure 80. Exemple d’aléas de données

La solution est de “Renvoyer” résultat d ’une étape vers une autre

Figure 81. Solution de l’aléa de données

68
Références Bibliographiques

[1] J. L. Hennessy and D. A. Patterson, Architecture des ordinateurs, Dunod, Paris 1996.

[2]  J. L. Hennessy and D. A. Patterson, Computer Architecture: A Quantitative Approach, 2nd


Edition, Morgan Kaufmann Publishing Co., Menlo Park, CA, 1996.

[3] Dominic Sweetman, See MIPS Run, 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

Vous aimerez peut-être aussi