Processeur MIPS - Xavier Perseguers

Architecture des Ordinateurs
Processeur MIPS
Rapport
Xavier Perseguers, [email protected]
Tadeusz Senn, [email protected]
1er mai 2002
ÉCOLE POLYTECHNIQUE
FÉDÉRALE DE LAUSANNE
Rapport : Processeur MIPS – BB
1
Processeur MIPS – BB
Introduction
Ce rapport présente la réalisation d’un processeur MIPS 32 bits en
VHDL. Le processeur, surnommé BB, a été créé avec un petit nombre d’instructions (arithmétiques : ADD, SUB et ADDI ; logiques : AND et OR ; de
saut conditionnel : BEQ ; et d’accès à la mémoire : SW et LW ). La technique
du pipelining n’a pas été abordée.
Il décrit la méthodologie utilisée pour implémenter le processeur, les tests
effectués pour vérifier son bon fonctionnement, les problèmes rencontrés et
leurs solutions, ainsi que certaines améliorations possibles.
Méthodologie
La méthodologie choisie a été de créer les composants et de les tester au
fur et à mesure.
Nous utilisons au maximum la bibliothèque arithmétique. De cette façon,
notre approche est plus comportementale que structurelle. C’est aussi pourquoi nous préférons ne pas réutiliser les composants développés séparément.
Unité de contrôle
L’unité de contrôle est une machine de Moore, i.e. une machine dont
l’état futur ne dépend que de l’état présent. Elle est composée de sept états
organisés selon la figure 1 :
Fetch : lecture de l’instruction suivante (IRWrite et MemiCS à 1 ), incrémentation du Program Counter (PC) (PCWrite activé, et PCSrc désactivé pour que le PC soit incrémenté de la valeur par défaut 4, i.e.
P C = P C + 4 comme dans tous les états où il est désactivé).
Decode : détermination de l’état futur en fonction de l’instruction lue dans
l’état Fetch. De plus, si l’instruction est un SW, préparation de l’adresse
en désactivant ALUSrc (explications dans la section Problèmes et Solutions, en page 6).
Rapport : Processeur MIPS – BB
2
Fetch
LW
Op LW
Op Addi
Decode
Addi
Op BEQ
Op SW
Op R-Type
BEQ
SW
R-Type
Fig. 1 – Graphe des états de l’unité de contrôle
Les états suivants sont des opérations :
Addi
ALUCtrl : signal à 010 pour effectuer l’addition avec l’ALU.
ALUSrc : activé (signal à 1 ) pour sélectionner la valeur immédiate
comme l’une des sources de l’addition.
RegWrite : activé pour enregistrer le résultat dans un registre.
RegDst : désactivé (signal à 0 ) pour prendre l’adresse du registre
destination RT venant des bits 20 à 16 de l’instruction.
BEQ
ALUCtrl : signal à 110 pour effectuer une soustraction avec l’ALU.
La soustraction permet de comparer la valeur des deux registres.
Si le résultat est nul, le flag zero de l’ALU sera activé et provoquera la mise à jour du PC.
PCSrc : activé pour remplacer la valeur du PC par la sortie de l’additionneur calculant le Branch Target.
PCWriteCond : activé pour écrire dans le PC pour autant que le bit
zero de l’ALU soit aussi activé.
ALUSrc : désactivé pour que la seconde sortie du Register File arrive
sur l’ALU.
Rapport : Processeur MIPS – BB
3
RegDst : désactivé pour prendre l’adresse du registre destination RT
venant des bits 20 à 16 de l’instruction.
SW
ALUCtrl : signal à 010 pour effectuer une addition avec l’ALU. L’addition permet de calculer l’adresse mémoire en combinant l’adresse
stockée et l’offset.
ALUSrc : activé pour prendre comme seconde opérande de l’ALU les
16 bits de poids faible (sign extended), c’est-à-dire la partie offset
de l’instruction.
MemdCS : activé pour sélectionner la mémoire.
MemdWE : activé pour remplacer le contenu de la mémoire désigné
par l’adresse par le contenu de DataIn.
RegDst : désactivé pour prendre l’adresse du registre destination RT
venant des bits 20 à 16 de l’instruction.
LW
ALUCtrl : signal à 010 pour calculer l’adresse mémoire comme dans
l’état SW.
ALUSrc : activé comme dans l’état SW.
MemdCS : activé comme dans l’état SW.
MemtoReg : activé pour copier le contenu de la mémoire dans un
registre.
RegWrite : activé pour autoriser l’écriture dans le registre.
RegDst : désactivé pour prendre l’adresse du registre destination RT
venant des bits 20 à 16 de l’instruction.
R-Type
ALUCtrl : déterminé par les bits Funct de l’instruction. Permet de
choisir l’opération arithmétique ou logique à effectuer.
RegDst : activé pour signifier que le registre de destination du résultat
de l’opération est déterminé par les bits 15 à 11 de l’instruction
(partie RD).
RegWrite : activé comme dans l’état LW.
ALUSrc : désactivé pour que la seconde sortie du Register File arrive
sur l’ALU.
Donner une valeur initiale à tous les signaux sortants, y compris l’état futur,
empêche la synthèse de latches et simplifie le code. De plus, cela permet au
circuit d’être dans un état stable par défaut.
1
0
Addi
010
1
Beq
010
0
SW
010
1
LW
110
1
1
1
1
R-Type (ALUCtrl[2..0]/Funct[5..0])
Add
Sub
And
Or
010/100000 110/100010 000/100100 001/100101
0
0
0
0
1
1
1
Rapport : Processeur MIPS – BB
Fetch
ALUCtrl[2..0]
ALUSrc
IRWrite
MemdCS
MemdWE
MemiCS
MemtoReg
PCSrc
PCWrite
PCWriteCond
RegDst
RegWrite
Etat suivant
Decode
SW Autres
1
1
0
1
Decode
1
0
0
0
1
1
1
1
1
1
1
1
1
Fetch
Tab. 1 – Synthèse des signaux de l’unité de contrôle — inspiré de la figure 5.20 p. 361 du COD.
4
Rapport : Processeur MIPS – BB
5
Tests Effectués
La première vérification du bon fonctionnement a été faite avec le programme proposé dans la mémoire d’instructions. Ensuite, les opérations logiques (AND et OR) ainsi que l’accès en écriture à la mémoire (SW ) ont
été rajoutés parce qu’ils n’étaient pas testés dans le programme original.
Enfin, nous avons écrit un programme calculant le produit de deux facteurs initialement stockés en mémoire (cf. listing 1). Le programme est structuré comme une procédure. Les adresses des deux facteurs sont stockées
respectivement dans $a0 et $a1, et celle de retour, dans $v0. La première
partie permet d’initialiser le contenu de la mémoire (memdata) ; la seconde
effectue la multiplication, basée sur sa définition mathématique :
a·b=
a
X
b
1
Listing 1: Programme de multiplication : 6 · 8
1
3
4
5
6
7
8
9
11
13
14
15
16
17
18
19
20
21
22
23
25
26
# Initialization
addi
addi
add
addi
addi
sw
sw
$s0 ,
$s1 ,
$a0 ,
$a1 ,
$v0 ,
$s0 ,
$s1 ,
$zero , 6
$zero , 8
$zero , $ z e r o
$a0 , 4
$a1 , 4
0 ( $a0 )
0 ( $a1 )
# $s0 = 6
# $s1 = 8
# $a0 = 0
# $a1 = 4
# $v0 = 8
# mem[ $a0 ] = $s0
# mem[ $a1 ] = $s1
# Multiplication
lw
lw
add
add
Loop :
add
addi
beq
beq
End :
sw
$s0
$s1
$s2
$s3
,
,
,
,
$s2 ,
$s3 ,
$s3 ,
$zero
0 ( $a0 )
0 ( $a1 )
$zero , $ z e r o
$zero , $ z e r o
#
#
#
#
$s2 , $s1
$s3 , 1
$s0 , End
, $zero , Loop
# $s2 = $s2 + $s1
# $s3 = $s3 + 1
# i f $s3=$s1 GOTO End
# GOTO Loop
$s2 , 0 ( $v0 )
$s0
$s1
$s2
$s3
=
=
:
:
operand #1
operand #2
temp r e s u l t
loop counter
# mem[ $v1 ] <= r e s u l t
Eternity :
beq $zero , $zero , E t e r n i t y # i n f i n i t e l o o p
Rapport : Processeur MIPS – BB
6
Fig. 2 – Déroulement du programme
Problèmes et Solutions
Le premier problème est apparu lors de la simulation : un signal avait
une valeur ‘X’ alors que le programme n’utilisait que des ‘0’ et des ‘1’. Nous
avions initialisé les signaux dans le processus Reset de l’unité de contrôle
(processus propre) et au début du processus principal. Or l’un des signaux
avait une autre assignation dans l’état Fetch. Comme solution, seul l’état
est remis à Fetch dans le Reset, et tous les signaux sont initialisés à chaque
coup d’horloge dans le processus principal.
Dans l’ALU, le flag zero doit être activé quand un résultat est nul.
Comme le résultat temporaire (dans notre cas tp result) est défini comme
un signal, il est indispensable de définir la valeur de ce flag à l’extérieur du
processus de calcul sous peine d’avoir un décalage d’un coup d’horloge entre
le nouveau résultat et son activation éventuelle.
L’opération de saut conditionnel BEQ peut être effectuée, théoriquement,
par les opérations AND ou SUB de l’ALU. En pratique, le signal zero est indispensable pour que la valeur du PC puisse être différente de P C = P C +4 ;
d’où le choix de la soustraction qui active ce signal si les opérandes sont
égales.
Le dernier problème s’est posé avec l’instruction SW. En effet, lors des
premiers tests et comme nous nous sommes basés tout d’abord sur le graphe
des états du cours (cf. figure 1, p. 2), l’instruction commençait par écrire
n’importe où en mémoire avant de le faire à la bonne adresse. En examinant le schéma de l’unité de traitement, il est apparu que l’adresse n’est
valide qu’après son calcul dans l’ALU, lequel requière un coup d’horloge
supplémentaire par rapport au signal de sélection en écriture de la mémoire
(MemdWE ). Ainsi, il était envisageable d’ajouter un état intermédiaire,
entre les états Decode et SW, pour laisser du temps à l’ALU. Toutefois
nous avons trouvé plus astucieux de préparer l’adresse dans l’état Decode.
Rapport : Processeur MIPS – BB
7
Améliorations
Le design du processeur mis à part, des améliorations au niveau des
performances et des possibilités intrinsèques sont envisageables.
Actuellement, toutes les instructions demandent, pour s’exécuter, trois
coups d’horloge pendant lesquels une partie du processeur n’est pas utilisée. Il serait intéressant d’implémenter le pipelining pour réduire le temps
total d’exécution et avoir une meilleure gestion des ressources du processeur. Le pipelining permet de commencer à exécuter une nouvelle instruction alors que la précédente est encore traitée. Il faut évidemment remarquer
qu’une instruction de saut ou un test empêchent l’application de cette technique. Le nombre de coups d’horloge pour une instruction n’est pas réduit,
mais comme les opérations se chevauchent, le temps total d’exécution d’une
séquence d’instructions est diminué.
Le Processeur MIPS – BB a un jeu d’instructions quelque peu restreint.
Des instructions telles que des décalages (SLL et SRL), un autre comparateur (SLT ) et une nouvelle opération logique (NOR) augmenteraient
de façon significative les possibilités de programmation. Les décalages permettent des multiplications et divisions par 2 ; le comparateur ‘<’ complète
les instructions de sauts conditionnels ; et le NOR permet de calculer toutes
les autres fonctions logiques, en particulier la fonction NOT.
Enfin, la gestion des exceptions permettrait de détecter les dépassements
de capacité dans les opérations arithmétiques ainsi que les instructions non
reconnues ou incorrectes.
Conclusion
17.04.2002 11h49: ÇA MARCHE !!!
Pour réaliser le Processeur MIPS – BB, les solutions choisies — par
exemple les bibliothèques arithmétiques — nous sont apparues comme évidentes du fait de leur simplicité et de leur logique. De plus, plutôt que de
coder les instructions utilisées pour la multiplication en binaire, nous avons
préféré créer, en informaticiens, le programme MIPS Assembler 1 .
Finalement, ce projet nous a permis de nous familiariser avec la logique
d’un processeur, son architecture et son fonctionnement. Nous espérons garder en mémoire les quelques subtilités découvertes pour pouvoir les exploiter
dans notre avenir en ingénierie informatique.
1. Disponible sur http://diwww.epfl.ch/∼persegue/mips/
Rapport : Processeur MIPS – BB
8
Références
[1] D.A. Patterson et J.L. Hennessy. Computer Organization & Design,
2nd Edition. Morgan Kaufmann Publishers, 1998.
[2] E. Sanchez et P. Ienne. Notes du cours Conception des Processeurs,
2001-2002.
[3] E. Sanchez et P. Ienne. Notes du cours Architecture des Ordinateurs,
2002.
[4] B. Orwell. Nineteen Eighty-Four. Penguin Books, 1948.
Rapport : Processeur MIPS – BB
9
Annexes
Fichiers VHDL
add synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
alu synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .11
and 2 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
controlunit synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
ir synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
memdata synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
meminstr synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
mux 2 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
or 2 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
pc synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
reg 32 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
regfile 32 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26
shiftleft2 synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
signextend synth.vhd . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Rapport : Processeur MIPS – BB
Listing 2: add synth.vhd
1
2
3
4
6
7
8
9
10
11
12
14
15
17
18
19
20
LIBRARY
USE i e e e
USE i e e e
USE i e e e
ieee ;
. std logic 1164 . all ;
. std logic arith . all ;
. std logic unsigned . all ;
ENTITY add IS
PORT(
a
: IN
b
: IN
r e s u l t : OUT
);
END add ;
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
s t d l o g i c v e c t o r ( 3 1 downto 0 )
−− Simple o pé r a t i o n a r i t h m é t i q u e ( a d d i t i o n )
−− u t i l i s a n t l a b i b l i o t h è q u e a r i t h m é t i q u e
ARCHITECTURE synth OF add IS
BEGIN
r e s u l t <= a + b ;
END synth ;
10
Rapport : Processeur MIPS – BB
11
Listing 3: alu synth.vhd
1
2
3
4
6
7
8
9
10
11
12
13
14
16
17
18
20
21
23
24
25
26
27
28
29
30
31
32
34
36
37
38
39
40
41
42
LIBRARY
USE i e e e
USE i e e e
USE i e e e
ieee ;
. std logic 1164 . all ;
. std logic arith . all ;
. std logic unsigned . all ;
ENTITY a l u IS
PORT(
a
:
b
:
result :
zero
:
op
:
);
END a l u ;
IN
IN
OUT
OUT
IN
std
std
std
std
std
logic
logic
logic
logic
logic
v e c t o r ( 3 1 downto 0 ) ;
v e c t o r ( 3 1 downto 0 ) ;
v e c t o r ( 3 1 downto 0 ) ;
;
v e c t o r ( 2 downto 0 )
ARCHITECTURE synth OF a l u IS
SIGNAL t p r e s u l t : s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
BEGIN
−− P r o c e s s u s p r i n c i p a l dé c o d a n t l e s i g n a l op .
−− Choix de ‘U’ pour d e s o p é r a t i o n s non reconnues
PROCESS ( op , a , b )
BEGIN
CASE op IS
WHEN ” 000 ” => t p r e s u l t <= a AND b ;
WHEN ” 001 ” => t p r e s u l t <= a OR b ;
WHEN ” 010 ” => t p r e s u l t <= a + b ;
WHEN ” 110 ” => t p r e s u l t <= a − b ;
WHEN others => t p r e s u l t <= (OTHERS = > ’U ’ ) ;
END CASE;
END PROCESS;
−− G e s t i o n du f l a g z e r o
PROCESS ( t p r e s u l t )
BEGIN
IF ( t p r e s u l t = ( 3 1 downto 0 = > ’ 0 ’ ) ) THEN
z e r o <= ’1 ’;
ELSE
z e r o <= ’0 ’;
END IF ;
Rapport : Processeur MIPS – BB
43
45
46
48
50
END PROCESS;
−− Passage par un s i g n a l t e m p o r a i r e pour que l a
−− s o r t i e r e s u l t a i t t o u j o u r s une v a l e u r
r e s u l t <= t p r e s u l t ;
END synth ;
12
Rapport : Processeur MIPS – BB
Listing 4: and 2 synth.vhd
1
2
3
5
6
7
8
9
10
11
13
14
16
17
18
19
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
USE i e e e . s t d l o g i c a r i t h . a l l ;
ENTITY And
PORT(
In0
In1
Out0
);
END And 2 ;
2 IS
: IN
: IN
: OUT
std logic ;
std logic ;
std logic
−− Simple o pé r a t i o n l o g i q u e (ET l o g i q u e )
−− u t i l i s a n t l a b i b l i o t h è q u e a r i t h m é t i q u e
ARCHITECTURE synth OF And 2 IS
BEGIN
Out0 <= In0 AND In1 ;
END synth ;
13
Rapport : Processeur MIPS – BB
14
Listing 5: controlunit synth.vhd
1
2
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
23
ENTITY C o n t r o l U n i t IS
PORT(
Funct
: IN
Op
: IN
clk
: IN
reset
: IN
ALUCtrl
: OUT
ALUSrc
: OUT
IRWrite
: OUT
MemdCS
: OUT
MemdWE
: OUT
MemiCS
: OUT
MemtoReg
: OUT
PCSrc
: OUT
PCWrite
: OUT
PCWriteCond : OUT
RegDst
: OUT
RegWrite
: OUT
);
END C o n t r o l U n i t ;
25
ARCHITECTURE synth OF C o n t r o l U n i t IS
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
27
28
29
30
31
33
35
36
38
39
41
42
std
std
std
std
std
std
std
std
std
std
std
std
std
std
std
std
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
logic
v e c t o r ( 5 downto 0 ) ;
v e c t o r ( 5 downto 0 ) ;
;
;
v e c t o r ( 2 downto 0 ) ;
;
;
;
;
;
;
;
;
;
;
−− d é c l a r a t i o n d e s 7 é t a t s
type State Type i s ( Fetch , Decode , Addi , Beq ,
RType , SW, LW) ;
s i g n a l c u r r e n t s t a t e : State Type ;
s i g n a l n e x t s t a t e : State Type ;
BEGIN
PROCESS ( c u r r e n t s t a t e , op , Funct )
BEGIN
−− I n i t i a l i s a t i o n de t o u s l e s s i g n a u x
−− à chaque changement d ’ é t a t
ALUCtrl
ALUSrc
<= (OTHERS = > ’ 0 ’ ) ;
<= ’0 ’;
Rapport : Processeur MIPS – BB
53
IRWrite
MemdCS
MemdWE
MemiCS
MemtoReg
PCSrc
PCWrite
PCWriteCond
RegDst
RegWrite
next state
55
CASE c u r r e n t s t a t e IS
43
44
45
46
47
48
49
50
51
52
57
59
60
61
62
63
65
66
68
69
70
71
72
73
74
75
76
77
78
79
80
82
84
85
86
15
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= ’0 ’;
<= Fetch ;
−− Fetch : Charger l ’ i n s t r u c t i o n s u i v a n t e
WHEN Fetch =>
IRWrite <= ’1 ’;
PCWrite <= ’1 ’;
MemiCS <= ’1 ’;
n e x t s t a t e <= Decode ;
−− Decode : Décoder l ’ i n s t r u c t i o n
−−
Pour SW, c a l c u l e r l ’ a d r e s s e en p l u s
WHEN Decode =>
CASE Op IS
WHEN ” 001000 ” => n e x t s t a t e <= Addi ;
WHEN ” 000100 ” => n e x t s t a t e <= Beq ;
WHEN ” 000000 ” => n e x t s t a t e <= RType ;
WHEN ” 101011 ” =>
ALUCtrl <= ” 010 ” ;
ALUSrc <= ’1 ’;
MemdCS <= ’1 ’;
n e x t s t a t e <= SW;
WHEN ” 100011 ” => n e x t s t a t e <= LW;
WHEN OTHERS => n e x t s t a t e <= Fetch ;
END CASE;
−− O pé r a t i o n s
WHEN Addi =>
ALUCtrl <= ” 010 ” ;
ALUSrc <= ’1 ’;
Rapport : Processeur MIPS – BB
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
118
119
121
122
123
124
125
126
127
128
130
RegWrite <= ’1 ’;
WHEN Beq =>
−− S o u s t r a c t i o n pour un s a u t
ALUCtrl <= ” 110 ” ;
PCSrc <= ’1 ’;
PCWriteCond <= ’1 ’;
WHEN RType =>
−− Choix de l ’ o pé r a t i o n de t y p e R−t y p e
CASE Funct IS
WHEN ” 100000 ” => ALUCtrl <= ” 010 ” ;
WHEN ” 100010 ” => ALUCtrl <= ” 110 ” ;
WHEN ” 100100 ” => ALUCtrl <= ” 000 ” ;
WHEN ” 100101 ” => ALUCtrl <= ” 001 ” ;
WHEN OTHERS => ALUCtrl <= ”UUU” ;
END CASE;
RegDst <= ’1 ’;
RegWrite <= ’1 ’;
WHEN SW =>
ALUCtrl <= ” 010 ” ;
ALUSrc <= ’1 ’;
MemdCS <= ’1 ’;
MemdWE <= ’1 ’;
WHEN LW =>
ALUCtrl <= ” 010 ” ;
ALUSrc <= ’1 ’;
MemdCS <= ’1 ’;
MemtoReg <= ’1 ’;
RegWrite <= ’1 ’;
END CASE;
END PROCESS;
−− P r o c e s s u s Reset :
−− I n i t i a l i s e uniquement l ’ é t a t c o u r a n t
PROCESS ( c l k , r e s e t )
BEGIN
IF ( r e s e t = ’ 1 ’ ) THEN
c u r r e n t s t a t e <= f e t c h ;
ELSIF ( c l k ’ e v e n t AND c l k = ’ 1 ’ ) THEN
c u r r e n t s t a t e <= n e x t s t a t e ;
END IF ;
END PROCESS;
END synth ;
16
Rapport : Processeur MIPS – BB
Listing 6: ir synth.vhd
1
2
4
5
6
7
8
9
10
11
13
14
16
17
18
20
21
22
23
24
25
26
27
29
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY IR
PORT(
a
q
we
clk
);
END IR ;
IS
:
:
:
:
IN
OUT
IN
IN
std
std
std
std
l o g i c v e c t o r ( 3 1 downto 0 ) ;
l o g i c v e c t o r ( 3 1 downto 0 ) ;
logic ;
logic
ARCHITECTURE synth OF IR IS
BEGIN
−− R e g i s t r e d ’ i n s t r u c t i o n ( 3 2 b i t s )
−− a c t i v é en é c r i t u r e avec un s i g n a l
−− s u p p lé m e n t a i r e ( ‘ we ’ )
PROCESS ( c l k , a , we )
BEGIN
IF ( c l k ’ e v e n t AND c l k = ’ 1 ’ ) THEN
IF ( we = ’ 1 ’ ) THEN
q <= a ;
END IF ;
END IF ;
END PROCESS;
END synth ;
17
Rapport : Processeur MIPS – BB
18
Listing 7: memdata synth.vhd
1
2
3
5
6
7
8
9
10
11
12
13
14
16
17
18
19
20
21
22
23
25
26
27
28
29
30
32
33
34
36
37
39
40
42
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
USE i e e e . s t d l o g i c u n s i g n e d . a l l ;
ENTITY memdata
PORT(
adr
Data Out
cs
we
Data In
oe
);
END memdata ;
IS
:
:
:
:
:
:
IN
OUT
IN
IN
IN
IN
std
std
std
std
std
std
logic
logic
logic
logic
logic
logic
v e c t o r ( 7 downto 0 ) ;
v e c t o r ( 3 1 downto 0 ) ;
;
;
v e c t o r ( 3 1 downto 0 ) ;
ARCHITECTURE synth OF memdata IS
TYPE memdtype IS ARRAY( ( ( 2 ∗ ∗ 8 ) / 4 ) − 1 downto 0 ) OF
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
SIGNAL memoired : memdtype :=
(0 = >
” 000000000000000000000000 000 0010 0 ” ,
1 =>
” 000000000000000000000000 000 0001 1 ” ,
OTHERS => ” 000000000000000000000000 000 0000 0 ” ) ;
BEGIN
−−
−−
−−
−−
−−
−−
Memoire de données :
Doit ê t r e s é l e c t i o n n é e ( ’ cs ’ )
p u i s deux modes : l e c t u r e e t é c r i t u r e
en f o n c t i o n de ‘ we ’
( c o n v i n t e g e r n é c e s s a i r e p a r c e que l ’ i n d e x de l a
mémoire e s t de t y p e i n t e g e r )
PROCESS ( cs , oe , we , adr , Data In )
BEGIN
Data Out <= (OTHERS = > ’Z ’ ) ;
IF ( c s = ’ 1 ’ ) THEN
IF ( we = ’ 1 ’ ) THEN
−− Mode : E c r i t u r e
memoired (CONV INTEGER( adr )) <= Data In ;
ELSE
Rapport : Processeur MIPS – BB
−− Mode : L e c t u r e
IF ( oe = ’ 1 ’ ) THEN
Data Out <= memoired (CONV INTEGER( adr ) ) ;
END IF ;
44
45
46
47
49
50
51
53
19
END IF ;
END IF ;
END PROCESS;
END synth ;
Rapport : Processeur MIPS – BB
Listing 8: meminstr synth.vhd
1
2
3
5
6
7
8
9
10
11
12
14
15
16
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
USE i e e e . s t d l o g i c u n s i g n e d . a l l ;
ENTITY meminstr IS
PORT(
adr : IN
data : OUT
cs
: IN
oe
: IN
);
END meminstr ;
std
std
std
std
l o g i c v e c t o r ( 7 downto 0 ) ;
l o g i c v e c t o r ( 3 1 downto 0 ) ;
logic ;
logic
ARCHITECTURE synth OF meminstr IS
TYPE memitype IS ARRAY( ( ( 2 ∗ ∗ 8 ) / 4 ) − 1 downto 0 ) OF
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
s i g n a l memoirei : memitype : = (
−− a d d i $s0 , $zero , 6
0 => ” 0010000000010000000000000 000 0110 ” ,
−− a d d i $s1 , $zero , 8
1 => ” 0010000000010001000000000 000 1000 ” ,
−− add $a0 , $zero , $ z e r o
2 => ” 0000000000000000001000000 010 0000 ” ,
−− a d d i $a1 , $a0 , 4
3 => ” 0010000010000101000000000 000 0100 ” ,
−− a d d i $v0 , $a1 , 4
4 => ” 0010000010100010000000000 000 0100 ” ,
−− sw $s0 , 0 ( $a0 )
5 => ” 1010110010010000000000000 000 0000 ” ,
−− sw $s1 , 0 ( $a1 )
6 => ” 1010110010110001000000000 000 0000 ” ,
−− lw $s0 , 0 ( $a0 )
7 => ” 1000110010010000000000000 000 0000 ” ,
−− lw $s1 , 0 ( $a1 )
8 => ” 1000110010110001000000000 000 0000 ” ,
−− add $s2 , $zero , $ z e r o
9 => ” 0000000000000000100100000 010 0000 ” ,
−− add $s3 , $zero , $ z e r o
10 => ” 0000000000000000100110000 010 0000 ” ,
−− add $s2 , $s2 , $s1
11 => ” 0000001001010001100100000 010 0000 ” ,
20
Rapport : Processeur MIPS – BB
52
−− a d d i $s3 , $s3 , 1
12 => ” 0010001001110011000000000 000 0001 ” ,
−− b e q $s0 , $s3 , 1
13 => ” 0001001001110000000000000 000 0001 ” ,
−− b e q $zero , $zero , −4
14 => ” 0001000000000000111111111 111 1100 ” ,
−− sw $s2 , 0 ( $v0 )
15 => ” 1010110001010010000000000 000 0000 ” ,
−− b e q $zero , $zero , −1
16 => ” 0001000000000000111111111 111 1111 ” ,
54
OTHERS => ” 000000000000000000000000 0000 000 0 ” ) ;
43
44
45
46
47
48
49
50
51
56
58
59
61
62
63
64
65
66
67
68
69
71
BEGIN
−− Mémoire d ’ i n s t r u c t i o n c o n t e n a n t l e programme
−− de m u l t i p l i c a t i o n
PROCESS ( cs , oe , adr )
BEGIN
IF ( c s = ’ 1 ’ AND oe = ’ 1 ’ ) THEN
data <= memoirei (CONV INTEGER( adr ) ) ;
ELSE
−− i n a c t i v e = > ’Z ’ en s o r t i e
data <= (OTHERS = > ’Z ’ ) ;
END IF ;
END PROCESS;
END synth ;
21
Rapport : Processeur MIPS – BB
Listing 9: mux 2 synth.vhd
1
2
4
5
6
7
8
9
10
11
13
14
16
17
18
19
21
22
23
24
25
26
27
28
30
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY mux 2 IS
PORT(
e0 : IN
e1 : IN
o
: OUT
s e l : IN
);
END mux 2 ;
std
std
std
std
l o g i c v e c t o r ( 3 1 downto 0 ) ;
l o g i c v e c t o r ( 3 1 downto 0 ) ;
l o g i c v e c t o r ( 3 1 downto 0 ) ;
logic
ARCHITECTURE synth OF mux 2 IS
BEGIN
−−
−−
−−
−−
M u l t i p l e x e u r 2 e n t r é e s de 3 2 b i t s
avec 1 b i t de c o n t r ô l e .
S i l e s i g n a l ‘ s e l ’ d i f f è r e de ‘ 0 ’ ou de ‘ 1 ’ ,
e n v o i de ‘U’ en s o r t i e
PROCESS ( e0 , e1 , s e l )
BEGIN
CASE s e l IS
WHEN ’ 0 ’
=> o <= e0 ;
WHEN ’ 1 ’
=> o <= e1 ;
WHEN OTHERS => o <= (OTHERS = > ’U ’ ) ;
END CASE;
END PROCESS;
END synth ;
22
Rapport : Processeur MIPS – BB
Listing 10: or 2 synth.vhd
1
2
4
5
6
7
8
9
10
12
13
15
16
17
18
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY o r 2
PORT(
In0
In1
Out0
);
END o r 2 ;
IS
: IN
: IN
: OUT
std logic ;
std logic ;
std logic
−− Simple o pé r a t i o n l o g i q u e (OU l o g i q u e )
−− u t i l i s a n t l a b i b l i o t h è q u e a r i t h m é t i q u e
ARCHITECTURE synth OF o r 2 IS
BEGIN
Out0 <= In0 OR In1 ;
END synth ;
23
Rapport : Processeur MIPS – BB
Listing 11: pc synth.vhd
1
2
4
5
6
7
8
9
10
11
12
14
15
17
18
20
21
22
23
24
25
26
27
28
29
31
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY pc IS
PORT(
clk
:
a
:
q
:
we
:
reset :
);
END pc ;
IN
IN
OUT
IN
IN
std
std
std
std
std
logic
logic
logic
logic
logic
;
v e c t o r ( 3 1 downto 0 ) ;
v e c t o r ( 3 1 downto 0 ) ;
;
ARCHITECTURE synth OF pc IS
BEGIN
−− R e g i s t r e PC 3 2 b i t s
−− P r o c e s s u s Reset e t p r i n c i p a l
PROCESS ( c l k , r e s e t )
BEGIN
IF ( r e s e t = ’ 1 ’ ) THEN
q <= (OTHERS = > ’ 0 ’ ) ;
ELSIF ( c l k ’ e v e n t and c l k = ’ 1 ’ ) THEN
IF ( we = ’ 1 ’ ) THEN
q <= a ;
END IF ;
END IF ;
END PROCESS;
END synth ;
24
Rapport : Processeur MIPS – BB
25
Listing 12: reg 32 synth.vhd
1
2
4
5
6
7
8
9
10
12
13
14
16
17
19
20
21
22
23
24
26
28
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY r e g 3 2 IS
PORT(
c l k : IN
a
: IN
q
: OUT
);
END r e g 3 2 ;
std logic ;
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
s t d l o g i c v e c t o r ( 3 1 downto 0 )
ARCHITECTURE synth OF r e g 3 2 IS
SIGNAL r e g s i g n a l : s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
BEGIN
−− R e g i s t r e 3 2 b i t s s é q u e n t i e l
−− sans s i g n a l Reset
PROCESS ( c l k )
BEGIN
IF ( c l k ’ e v e n t AND c l k = ’ 1 ’ ) THEN
r e g s i g n a l <= a ;
END IF ;
END PROCESS;
q <= r e g s i g n a l ;
END synth ;
Rapport : Processeur MIPS – BB
26
Listing 13: regfile 32 synth.vhd
1
2
3
5
6
7
8
9
10
11
12
13
14
15
16
18
19
20
21
22
24
26
27
29
30
31
33
34
36
37
38
39
40
42
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
USE i e e e . s t d l o g i c u n s i g n e d . a l l ;
ENTITY R e g F i l e
PORT(
clk
aa
ab
aw
a
b
WData
RegWrite
);
END R e g F i l e 3 2
3 2 IS
:
:
:
:
:
:
:
:
IN
IN
IN
IN
OUT
OUT
IN
IN
std
std
std
std
std
std
std
std
logic
logic
logic
logic
logic
logic
logic
logic
;
vector
vector
vector
vector
vector
vector
( 4 downto 0 ) ;
( 4 downto 0 ) ;
( 4 downto 0 ) ;
( 3 1 downto 0 ) ;
( 3 1 downto 0 ) ;
( 3 1 downto 0 ) ;
;
ARCHITECTURE synth OF R e g F i l e 3 2 IS
TYPE a d d r e s s t y p e i s array ( 3 1 downto 0 ) of
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
SIGNAL r f a d d r e s s : a d d r e s s t y p e ;
BEGIN
−− R e g i s t r e P r i n c i p a l
PROCESS ( aa , ab , c l k , RegWrite , aw )
BEGIN
−− S o r t i e s c o n s t a n t e s
a <= r f a d d r e s s (CONV INTEGER ( aa ) ) ;
b <= r f a d d r e s s (CONV INTEGER ( ab ) ) ;
−− E c r i t u r e s é q u e n t i e l l e
IF ( c l k ’ e v e n t AND c l k = ’ 1 ’ ) THEN
−− Adresse ‘ ‘ 0 0 0 ’ ’ i n t e r d i t e
IF ( RegWrite = ’ 1 ’ AND aw /= ” 000 ” ) THEN
r f a d d r e s s (CONV INTEGER ( aw)) <= WData ;
END IF ;
END IF ;
END PROCESS;
Rapport : Processeur MIPS – BB
44
45
47
−− R e g i s t r e z e r o
r f a d d r e s s (0) <= ( others = > ’ 0 ’ ) ;
END synth ;
27
Rapport : Processeur MIPS – BB
Listing 14: shiftleft2 synth.vhd
1
2
4
5
6
7
8
9
11
12
14
15
17
19
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY s h i f t l e f t 2 IS
PORT(
e n t r e e : IN
s t d l o g i c v e c t o r ( 3 1 downto 0 ) ;
s o r t i e : OUT
s t d l o g i c v e c t o r ( 3 1 downto 0 )
);
END s h i f t l e f t 2 ;
ARCHITECTURE synth OF s h i f t l e f t 2 IS
BEGIN
−− Décalage v e r s l a gauche de 2 b i t s
−− en a j o u t a n t d e s ’ 0 ’
s o r t i e <= e n t r e e ( 2 9 downto 0 ) & ” 00 ” ;
END synth ;
28
Rapport : Processeur MIPS – BB
Listing 15: signextend synth.vhd
1
2
4
5
6
7
8
9
11
12
14
16
18
LIBRARY i e e e ;
USE i e e e . s t d l o g i c 1 1 6 4 . a l l ;
ENTITY SignExtend IS
PORT(
e n t r e e : IN
s t d l o g i c v e c t o r ( 1 5 downto 0 ) ;
s o r t i e : OUT
s t d l o g i c v e c t o r ( 3 1 downto 0 )
);
END SignExtend ;
ARCHITECTURE synth OF SignExtend IS
BEGIN
−− E x t e n s i o n du b i t 1 5 aux b i t s 31 −16 de l ’ e n t ré e
s o r t i e <= (31 downto 16 = > e n t r e e ( 1 5 ) ) & e n t r e e ;
END synth ;
29