Vous êtes sur la page 1sur 25

Circuits VLSI

Conception d’un multiplieur de Booth 16× 16 et son int´egration dans un microprocesseur

5 d´ecembre 2013

´

S. JOVANOVI C

1

Table des mati`eres

Table des mati`eres

1

Introduction .

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

3

1.1

Multiplieur de Booth

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

3

1.1.1 Introduction

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

3

1.1.2 L’encodage de Booth Radix-4

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

4

1.1.3 Multiplieur de Booth : architecture

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

5

1.2

Processeur MIPS

 

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

6

1.2.1 L’encodage d’instruction

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

6

1.2.2 Architecture du processeur .

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

8

1.2.3 Exemple de code

 

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

11

1.2.4 Contenu de la m´emoire et son d´ecodage .

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

12

1.2.5 Code VHDL [WH10]

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

13

2

V´erification du syst`eme

 

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

25

3

R´ef´erences

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

.

25

1

Introduction

Dans plusieurs traitement de signaux discrets (corr´elations, convolutions, filtrage ou anal- yse fr´equentielle), l’addition et la multiplication sont des op´erateurs indispensables. De ce fait, plusieurs algorithmes d’addition et de multiplication ont ´et´e ´etudi´es et impl´ement´es sous plusieurs formes : dans des processeurs de calcul sp´ecialis´e - DSP (Digital Signal Processor ) sous forme logicielle ou dans des circuits int´egr´es (ASIC ou reconfigurables de type FPGA) sous forme mat´erielle. L’´evolution des technologies de l’int´egration des circuits ´electroniques a fait que les recherches dans le domaine architectural se font de plus en plus pouss´ees. Ces recherches visent a` am´eliorer des performances temporelles des ´el´ements a` int´egrer ainsi qu’`a diminuer la surface de silicium occup´ee (pour r´eduire le coˆut de fabrication). Ce doc- ument concerne une ´etude architecturale d’un type de multiplieurs et son int´egration dans un microprocesseur. L’objectif principal de ce projet est de concevoir un multiplieur 16 × 16 utilisant le codage de Booth de type Radix-4 et de l’int´egrer dans un microprocesseur. L’´etudiant aura a` disposition le code VHDL d´ecrivant une architecture simplifi´ee d’un microprocesseur 8 bits de type MIPS, toute la documentation permettant de comprendre son fonctionnement et un exemple de code machine avec son ´equivalent en assembleur montrant son fonctionnement sur un cas concret. Le chemin de donn´ees est bas´e sur une architecture de Von Neuman utilisant un bus de donn´ee d’une taille de 8 bits. Pour pouvoir int´egrer le multiplieur 16 × 16 dans le chemin de donn´ees propos´e, l’´etudiant sera amen´e a` faire une adaptation de taille de donn´ee sans modifier le multiplier. Les nombres `a traiter sont cod´es en compl´ement a` 2. Ce projet est r´eparti en deux phases. Dans la premi`ere phase, le multiplieur a` concevoir devra ˆetre dans un premier temps d´ecrit, valid´e et test´e en tant qu’une unit´e ind´ependante au niveau comportemental/structurel en utilisant le langage de description VHDL et ensuite int´egr´e dans le microprocesseur mis a` disposition. Dans la deuxi`eme phase, le syst`eme complet (le microprocesseur et le multiplieur ) d´evelopp´e et test´e dans la premi`ere phase devra ˆetre impl´ement´e en tant qu’un ASIC dans la technologie AMS 0.35µm. Dans le travail demand´e, on utilisera les outils Cadence et Mentor Graphics dont la prise en main a fait partie du premier TP.

1.1 Multiplieur de Booth

1.1.1 Introduction

Le principe du codage de Booth est de r´eduire de moiti´e le nombre de produits partiels en analysant des groupes de bits du multiplicande. Ce recodage permet de transformer une s´erie de 1 par des 0 en se basant sur l’identit´e suivante :

2 i + 2 i+1 + 2 i+2 + ··· + 2 i+k

= 2 i+k+1 2 i

(1)

1.1

Multiplieur de Booth

En utilisant les chiffres 1, 0 et -1 (not´e 1), on peut remplacer une suite de zero ou de 1 dans un nombre binaire comme suit :

0111110001101011 = 1000010010111101

(2)

1.1.2 L’encodage de Booth Radix-4

a

2i+1

a

2i

a

2i1

P

i

 

0

0

 

0

0

0

0

1

+B

0

1

0

+B

0

1

1

+2B

1

0

0

-2B

1

0

1

-B

1

1

0

-B

1

1

1

0

Tab. 1: La table d’encodage de produits partiels pour l’algorithme Booth Radix-4

A

=

n

2

1

i=0

(a 2i1 + a 2i 2a 2i+1 )

{−2,1,0,+1,+2}

2 2i , o`u a 1 = 0

P = A · B =

=

n

2

1

i=0

(a 2i1 + a 2i 2a 2i+1 )

{−2,1,0,+1,+2}

2

2i

A

n

2 1

i=0

(a 2i1 + a 2i 2a 2i+1 ) · B

{−2B,B,0,+B,+2B}

n

2

1


=

i=0

P i · 2 2i

·B

·2 2i

(3)

(4)

Quelques exemples de multiplication avec l’encodage de Booth sont pr´esent´es ci-dessous. Les op´erandes sont cod´es en compl´ement `a 2.

1.1

Multiplieur de Booth

Example 1 : 2 entiers positifs

0111

multiplicande B multiplicateur A = (a 3 a 2 a 1 a 0 )

0011(0)

11111001

a 1 a 0 a 1 =

110 → −B

0111

a

3 a 2 a 1

= 001

+B

(1)00010101

R´esultat

S = A · B = 7 10 · 3 10 = 21 10

Example 2 : un entier positif, un n´egatif

1101

multiplicande B multiplicateur A = (a 3 a 2 a 1 a 0 )

0111(0)

00000011

a 1 a 0 a 1 =

110 → −B

111010

a

3 a 2 a 1

= 011

+2B

11101011

R´esultat S = A · B = (3) 10 · 7 10 = (21) 10

Example 3 : 2 entiers n´egatifs

1101

multiplicande B multiplicateur A = (a 3 a 2 a 1 a 0 )

1001(0)

11111101

a 1 a 0 a 1 =

010 B

000110

a

3 a 2 a 1

= 100

→ −2B

(1)00010101

R´esultat S = A · B = (3) 10 · (7) 10 = (21) 10

1.1.3 Multiplieur de Booth : architecture

A

B X X X Matrice/arbre CSA Additionneur CPA Encodage de Booth
B
X
X
X
Matrice/arbre CSA
Additionneur CPA
Encodage
de
Booth

(5)

(6)

(7)

Fig. 1: Sch´ema synoptique d’un multiplieur de Booth

1.2

Processeur MIPS

Le sch´ema synoptique de l’architecture d’un multiplieur de Booth est pr´esent´e sur la figure 1. Les ´el´ements principaux sont : le bloc pour l’encodage de Booth qui, en fonction des valeurs de bits du multiplicateur A, g´en`ere des signaux de contrˆole d´efinissant le type d’op´eration `a effectuer sur le multiplicande B (pas d’op´eration sur B, inversion du B, d´ecalage du B, inversion et d´ecalage du B), les blocs de calcul de produits partiels, l’arbre CSA pour la somme des produits partiels et un additionneur a` propagation de retenue pour calculer le r´esultat final. L’arbre CSA (Carry Save Adder) est une architecture couramment utilis´ee pour addi- tionner plusieurs op´erandes en mˆeme temps. Un arbre CSA avec un additionneur CPA en dernier ´etage pour une addition de 4 op´erandes de 5 bits est pr´esent´e sur la figure 2.

C B A C B A C B A C B A C B A
C
B
A
C
B
A
C
B
A
C
B
A
C
B
A
4
4
4
3
3
3
2
2
2
1
1
1
0
0
0
B
A
B
A
B
A
B
A
B
A
FA
FA
FA
FA
FA
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
S
S
S
S
S
D
D
D
D
D
4
3
2
1
0
B
A
B
A
B
A
B
A
B
A
FA
FA
FA
FA
FA
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
S
S
S
S
S
CPA
B
A
B
A
B
A
B
A
B
A
FA
FA
FA
FA
FA
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
Cout
Cin
0
S
S
S
S
S
S
S
S
S
2 S
1 S
5
4
3
0

0

Fig. 2: Un arbre CSA utilis´e pour l’addition de 4 op´erandes de 5 bits

1.2 Processeur MIPS

1.2.1 L’encodage d’instruction

Dans le microprocesseur pr´esent´e, il existe 3 types d’instruction (figure 3)[WH10] :

— Les instructions de type R qui sont utilis´ees pour les op´erations arithm´etiques et n’utilisant que des registres internes du processeur (2 registres de source et un de destination)

— Les instructions de type I utilisant 2 registres du processeur et un op´erande (imme- diate ) de 16 bits stock´e dans la m´emoire et

1.2

Processeur MIPS

— Les instructions de type J utilis´ees pour les instructions de branchement sur une adresse cod´ee sur 26 bits.

de branchement sur une adresse cod´ee sur 26 bits. Fig. 3: L’encodage d’instruction [WH10] Le jeu

Fig. 3: L’encodage d’instruction [WH10]

Le jeu d’instruction de ce microprocesseur est pr´esent´e dans la figure 4.

de ce microprocesseur est pr´esent´e dans la figure 4. Fig. 4: Jeu d’instruction [WH10] Universit´e de

Fig. 4: Jeu d’instruction [WH10]

1.2

Processeur MIPS

1.2.2 Architecture du processeur

Les figures 5 et 7 pr´esentent respectivement les sch´emas synoptique et d´etaill´e du micro- processeur. La connexion entre le microprocesseur et la m´emoire est pr´esent´ee sur la figure 6 tandis que la machine d’´etat du microprocesseur est pr´esent´ee sur la figure 8. La figure 9 d´etaille les modes de fonctionnement de l’unit´e ALU.

9 d´etaille les modes de fonctionnement de l’unit´e ALU. Fig. 5: Le sch´ema synoptique du processeur

Fig. 5: Le sch´ema synoptique du processeur [WH10]

ALU. Fig. 5: Le sch´ema synoptique du processeur [WH10] Fig. 6: Le sch´ema de liaison entre

Fig. 6: Le sch´ema de liaison entre le microprocesseur et la m´emoire [WH10]

1.2

Processeur MIPS

1.2 Processeur MIPS Fig. 7: Le sch´ema d´etaill´e du processeur [WH10] Universit´e de Lorraine 9 Master

Fig. 7: Le sch´ema d´etaill´e du processeur [WH10]

1.2

Processeur MIPS

1.2 Processeur MIPS Fig. 8: La machin´e d’´etats du processeur [WH10] Universit´e de Lorraine 10 Master

Fig. 8: La machin´e d’´etats du processeur [WH10]

1.2

Processeur MIPS

1.2 Processeur MIPS Fig. 9: Les signaux de contrˆole de l’ALU [WH10] 1.2.3 Exemple de code

Fig. 9: Les signaux de contrˆole de l’ALU [WH10]

1.2.3 Exemple de code

Un exemple de programme en C, assembleur et son ´equivalent en code machine sont pr´esent´es dans les figures 10, 11 et 12.

machine sont pr´esent´es dans les figures 10, 11 et 12. Fig. 10: Le code C pour

Fig. 10: Le code C pour le programme calculant la suite de Fibonacci [WH10]

1.2

Processeur MIPS

1.2 Processeur MIPS Fig. 11: Le code assembleur pour le programme calculant la suite de Fibonacci

Fig. 11: Le code assembleur pour le programme calculant la suite de Fibonacci [WH10]

pour le programme calculant la suite de Fibonacci [WH10] Fig. 12: Le langage machine pour le

Fig. 12: Le langage machine pour le programme calculant la suite de Fibonacci [WH10]

1.2.4 Contenu de la m´emoire et son d´ecodage

Le contenu de la m´emoire est pr´esent´e dans la figure 13. La figure 14 d´etaille le d´ebut de d´ecodage de la m´emoire en consid´erant que le registre a` l’adresse 0 est R 0 , a` l’adresse 1 est R 1 , etc. A compl´eter cette liste.

1.2

Processeur MIPS

1 80020044

2 80070040

3 80e30045

4 00e22025

5 00642824

6 00a42820

7 10a70008

8 0064302a

9 10c00001

10 80050000

11 00e2302a

12 00c53820

13 00e23822

14 0800000f

15 80070000

16 a0470047

17 00000003

18 00000005

19 0000000c

1

R 2 5 16 ;

2

R 7 3 16 ;

3

R 3 C 16 ;

4

R 4 R 2 OR R 7 = 7 16 ;

5

R 5 R 3 AND R 4 = 4 16 ;

.

.

.

.

Fig. 14: D´ecodage du contenu de la m´emoire du microprocesseur

Fig. 13: Contenu de la m´emoire du micro- processeur

1.2.5 Code VHDL [WH10]

---------------------------------------------------------

--

mips.vhd

 

--

David_Harris@hmc.edu

9/9/03

 

--

Model

of

subset

of

MIPS

processor

described

in

Ch

1

---------------------------------------------------------

---------------------------------------------------------

----------------

---------------------------------------------------------

-----------------

Top

design

(testbench)

library

IEEE;

use

IEEE.STD_LOGIC_1164.all;

use

IEEE.STD_LOGIC_UNSIGNED.all;

entity

top

is

--

top-level

design

for

testing

generic(width:

 

integer

:=

8;

--

default

8-bit

datapath

 
 

regbits:

integer

:=

3);

--

and

3

bit

register

addresses

(8

regs)

end;

architecture

test

of

top

is

component

mips

generic(width:

integer

:=

 

8;

--

default

8-bit

datapath

 
 

regbits:

integer

:=

3);

--

and

3

bit

register

addresses

(8

regs)

port(clk,

reset:

 

in

STD_LOGIC;

 
 

memdata:

 

in

STD_LOGIC_VECTOR(width-1

downto

0);

memread,

memwrite:

out

STD_LOGIC;

 

adr,

writedata:

 

out

STD_LOGIC_VECTOR(width-1

downto

0));

 

1.2

Processeur MIPS

end

component;

component

memory

generic(width:

integer);

 
 

port(clk,

memwrite:

in

STD_LOGIC;

adr,

writedata:

in

STD_LOGIC_VECTOR(width-1

downto

0);

memdata:

out

STD_LOGIC_VECTOR(width-1

downto

0));

end

component;

signal

clk,

reset,

memread,

memwrite:

STD_LOGIC;

signal

memdata,

adr,

writedata:

STD_LOGIC_VECTOR(width-1

downto

0);

begin

--

dut:

mips

mips

being

tested

generic

port

map(width,

reset,

regbits)

memdata,

map(clk,

--

external

memory

for

code

and

data

memread,

memwrite,

adr,

writedata);

exmem:

memory

 

generic

map(width)

 
 

port

map(clk,

memwrite,

adr,

writedata,

memdata);

--

Generate

clock

with

10

ns

period

 

process

begin

 

clk

<=

’1’;

 

wait

for

5

ns;

clk

<=

’0’;

 

wait

for

5

ns;

end

process;

 

--

Generate

reset

for

first

two

clock

cycles

process

begin

 
 

reset

<=

’1’;

 

wait

for

22

ns;

reset

<=

’0’;

 

wait;

 

end

process;

 

--

check

that

7

gets

written

to

address

76

at

end

of

program

process

(clk)

begin

 
 

if

(clk’event

and

clk

=

’0’

and

memwrite

=

’1’)

then

 

if

(conv_integer(adr)

=

76

and

conv_integer(writedata)

=

7)

then

 

report

"Simulation

completed

successfully";

else

report

"Simulation

failed.";

end

if;

end

end

process;

if;

end;

---------------------------------------------------------

---------

---------------------------------------------------------

-----------------

End

of

Top

design

(testbench)

---------------------------------------------------------

-----------------

---------------------------------------------------------

--------------------------------

Memory

library

use

IEEE;

use

IEEE.STD_LOGIC_1164.all;

use

use

STD.TEXTIO.all;

IEEE.STD_LOGIC_UNSIGNED.all;

IEEE.STD_LOGIC_ARITH.all;

entity

memory

is

--

external

memory

accessed

by

MIPS

generic(width:

integer);

port(clk,

memwrite:

in

STD_LOGIC;

adr,

writedata:

in

STD_LOGIC_VECTOR(width-1

downto

0);

memdata:

out

STD_LOGIC_VECTOR(width-1

downto

0));

end;

1.2

Processeur MIPS

architecture

begin

synth

of

memory

is

process

is

file

mem_file:

text

open

read_mode

is

"memfile.dat";

 

variable

 

L:

line;

 

variable

ch:

character;

 

variable

index,

result:

integer;

 

type

ramtype

is

array

(255

downto

0)

of

STD_LOGIC_VECTOR(7

downto

0);

variable

 

mem:

ramtype;

 

begin

--

initialize

memory

from

file

--

memory

in

little-endian

format

--

80020044

means

mem[3]

=

80

and

mem[0]

=

44

for

i

in

0

to

255

loop

--

set

all

contents

low

 

mem(conv_integer(i))

:=

"00000000";

 

end

loop;

 

index

:=

0;

while

not

endfile(mem_file)

loop

 
 

readline(mem_file,

L);

for

j

in

0

to

3

loop

 
 

result

:=

0;

 

for

i

in

1

to

2

loop

 

read(L,

ch);

 

if

’0’

<=

ch

and

ch

<=

’9’

then

 
 

result

:=

result*16

+

character’pos(ch)-character’pos(’0’);

 

elsif

’a’

<=

ch

and

ch

<=

’f’

then

 
 

result

:=

result*16

+

character’pos(ch)-character’pos(’a’)+10;

 

else

report

"Format

error

on

line

"

&

integer’image(index)

 

severity

error;

 
 

end

if;

 

end

loop;

 
 

mem(index*4+3-j)

:=

conv_std_logic_vector(result,

width);

 

end

loop;

 

index

:=

index

+

1;

end

loop;

 

--

read

or

write

memory

 

loop

 
 

if

clk’event

and

clk

=

’1’

then

 

if

(memwrite

=

’1’)

then

mem(conv_integer(adr))

:=

writedata;

end

if;

 

end

if;

memdata

<=

mem(conv_integer(adr));

 

wait

on

clk,

adr;

 

end

loop;

 

end;

end

process;

---------------------------------------------------------

-----------------

-------------------------

---------------------------------------------------------

End

of

Memory

---------------------------------------------------------

-----------------

---------------------------------------------------------

----------------------------------

MIPS

library

IEEE;

use

IEEE.STD_LOGIC_1164.all;

entity

mips

is

--

simplified

MIPS

processor

1.2

Processeur MIPS

generic(width:

integer

:=

8;

--

default

8-bit

datapath

 
 

regbits:

integer

:=

3);

--

and

3

bit

register

addresses

(8

regs)

port(clk,

reset:

in

STD_LOGIC;

 

memdata:

 

in

STD_LOGIC_VECTOR(width-1

downto

0);

memread,

memwrite:

out

STD_LOGIC;

 

adr,

writedata:

out

STD_LOGIC_VECTOR(width-1

downto

0));

end;

architecture

struct

of

mips

is

component

controller

 

port(clk,

reset:

in

STD_LOGIC;

 

op:

in

STD_LOGIC_VECTOR(5

downto

0);

zero:

in

STD_LOGIC;

memread,

memwrite,

alusrca,

memtoreg,

 

iord,

pcen,

regwrite,

regdst:

out

STD_LOGIC;

pcsrc,

alusrcb,

aluop:

out

STD_LOGIC_VECTOR(1

downto

0);

 

irwrite:

out

STD_LOGIC_VECTOR(3

downto

0));

end

component;

 

component

alucontrol

 

port(aluop:

in

STD_LOGIC_VECTOR(1

downto

0);

funct:

in

STD_LOGIC_VECTOR(5

downto

0);

alucont:

out

STD_LOGIC_VECTOR(2

downto

0));

end

component;

component

datapath

generic(width,

regbits:

integer);

 

port(clk,

reset:

in

STD_LOGIC;

memdata:

in

STD_LOGIC_VECTOR(width-1

downto

0);

alusrca,

memtoreg,

iord,

pcen,

regwrite,

regdst:

in

STD_LOGIC;

pcsrc,

alusrcb:

in

STD_LOGIC_VECTOR(1

downto

0);

 

irwrite:

in

STD_LOGIC_VECTOR(3

downto

0);

alucont:

in

STD_LOGIC_VECTOR(2

downto

0);

zero:

out

STD_LOGIC;

instr:

out

STD_LOGIC_VECTOR(31

downto

0);

adr,

writedata:

out

STD_LOGIC_VECTOR(width-1

downto

0));

end

component;

signal

instr:

STD_LOGIC_VECTOR(31

downto

0);

signal

zero,

alusrca,

memtoreg,

iord,

pcen,

regwrite,

regdst:

STD_LOGIC;

signal

aluop,

pcsrc,

alusrcb:

STD_LOGIC_VECTOR(1

downto

0);

signal

irwrite:

STD_LOGIC_VECTOR(3

downto

0);

signal

alucont:

STD_LOGIC_VECTOR(2

downto

0);

begin

cont:

controller

port

map(clk,

reset,

instr(31

downto

alusrca,

26),

memtoreg,

zero,

memread,

iord,

pcsrc,

memwrite,

pcen,

regwrite,

aluop,

regdst,

irwrite);

alusrcb,

ac:

alucontrol

port

map(aluop,

instr(5

downto

0),

alucont);

dp:

datapath

generic

map(width,

regbits)

port

map(clk,

reset,

memdata,

alusrca,

memtoreg,

iord,

pcen,

regwrite,

regdst,

pcsrc,

alusrcb,

irwrite,

 

end;

alucont,

zero,

instr,

adr,

writedata);

---------------------------------------------------------

-----------------

---------------------------------------------------------

---------------------------

End

of

MIPS

---------------------------------------------------------

-----------------

---------------------------------------------------------

----------------------------

controller

1.2

Processeur MIPS

library

IEEE;

use

IEEE.STD_LOGIC_1164.all;

 

entity

controller

is

--

control

FSM

port(clk,

reset:

 

in

STD_LOGIC;

 

op:

in

STD_LOGIC_VECTOR(5

downto

0);

zero:

in

STD_LOGIC;

memread,

memwrite,

alusrca,

memtoreg,

 

iord,

pcen,

regwrite,

regdst:

out

STD_LOGIC;

pcsrc,

alusrcb,

aluop:

 

out

STD_LOGIC_VECTOR(1

downto

0);

 

irwrite:

out

STD_LOGIC_VECTOR(3

downto

0));

end;

architecture

synth

of

controller

is

type

statetype

is

(FETCH1,

FETCH2,

FETCH3,

FETCH4,

DECODE,

MEMADR,

LBRD,

LBWR,

SBWR,

RTYPEEX,

RTYPEWR,

BEQEX,

JEX);

constant

LB:

STD_LOGIC_VECTOR(5

downto

0)

:=

"100000";

constant

SB:

STD_LOGIC_VECTOR(5

downto

0)

:=

"101000";

constant

RTYPE:

STD_LOGIC_VECTOR(5

downto

0)

:=

"000000";

constant

BEQ:

STD_LOGIC_VECTOR(5

downto

0)

:=

"000100";

constant

J:

STD_LOGIC_VECTOR(5

downto

0)

:=

"000010";

signal

state,

nextstate:

statetype;

signal

state_sig:integer

range

0

to

15;

signal

pcwrite,

pcwritecond:

STD_LOGIC;

begin

process

if

(clk)

begin

clk’event

and

--

clk

state

=

register

then

’1’

if

reset

=

’1’

then

state

<=

FETCH1;

else

state

<=

nextstate;

 

end

if;

end

end

process;

if;

process

(state,

op)

begin

--

next

state

logic

case

state

is

when

FETCH1

=>

nextstate

<=

FETCH2;

 

when

FETCH2

=>

nextstate

<=

FETCH3;

when

FETCH3

=>

nextstate

<=

FETCH4;

when

FETCH4

=>

nextstate

<=

DECODE;

when

DECODE

=>

case

op

is

 

when

LB

|

SB

=>

nextstate

<=

MEMADR;

when

RTYPE

=>

nextstate

<=

RTYPEEX;

 

when

BEQ

=>

nextstate

<=

BEQEX;

when

J

=>

nextstate

<=

JEX;

 

when

others

=>

nextstate

<=

FETCH1;

--

should

never

happen

 

end

case;

 

when

MEMADR

=>

case

op

is

 

when

LB

=>

nextstate

<=

LBRD;

when

SB

=>

nextstate

<=

SBWR;

when

others

=>

nextstate

<=

FETCH1;

--

should

never

happen

 

end

case;

 

when

LBRD

=>

nextstate

<=

LBWR;

when

LBWR

=>

nextstate

<=

FETCH1;

when

SBWR

=>

nextstate

<=

FETCH1;

when

RTYPEEX

=>

nextstate

<=

RTYPEWR;

 

when

RTYPEWR

=>

nextstate

<=

FETCH1;

 

when

BEQEX

=>

nextstate

<=

FETCH1;

when

JEX

=>

nextstate

<=

FETCH1;

when

others

=>

nextstate

<=

FETCH1;

--

should

never

happen

 

end

end

process;

case;

1.2

Processeur MIPS

process

(state)

begin

 

--

set

all

outputs

to

zero,

then

conditionally

assert

just

the

appropriate

ones

irwrite

<=

"0000";

 

pcwrite

<=

’0’;

pcwritecond

<=

’0’;

 

regwrite