Está en la página 1de 98

ExposicinTecnolgicayCientfica

ETyC2010

Facultad Politcnica
Universidad Nacional de Asuncin

Curso:
Implementacin de un procesador de ruta de
datos sencilla en VHDL

MSc. Ral Peralta Meza


Docente del Programa Profesional de Ingeniera
de Telecomunicaciones
Universidad Catlica San Pablo

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Informacin general
Implementacin de un procesador en VHDL. 15 horas acadmicas. Contenido: Arquitectura de las
instrucciones de un procesador MIPS. Ruta de datos: memorias, ALU e implementacin en VHDL. Unidad de
Control y su implementacin en VHDL.
Pre-requisitos: Circuitos digitales combinacionales y secuenciales. Nociones de programacin en C.
Objetivos Generales del curso:
El curso examina los problemas bsicos en el diseo e implementacin de un procesador de ciclo sencillo que
ser implementado en VHDL y adems ser probado en tarjetas que contengan dispositivos lgicos
programables como FPGA. El curso describe las principales partes de un procesador como son la ruta de
datos, la unidad de control y programacin en VHDL usando el ISE de Xilinx. Los tpicos incluidos son:
arquitectura de instrucciones, archivos de registros, cache de datos e instrucciones, unidad aritmtica y lgica
(ALU), clculo de la siguiente instruccin. El curso permitir a los asistentes implementar y probar en VHDL
los bloques antes mencionados.
Objetivos especficos del curso:
Al final de curso el alumno ser capaz de:
1. Conocer y describir e implementar los principales componentes de un procesador.
2. Programar en VHDL los componentes de la ruta de datos y la unidad de control de un procesador
MIPS.
3. Aprender a usar los entornos de programacin de VHDL prvidos por XILINX. Adems de conocer
como programar tarjetas con FPGA.
4. Conocer las modernas prcticas que se emplean para el diseo de sistemas digitales de mediana y
alta complejidad.

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Contenido

Arquitecturadeljuegodeinstrucciones.............................................................................................9
InstruccionestipoR.......................................................................................................................11
InstruccionestipoI........................................................................................................................11
InstruccionestipoJ........................................................................................................................11
PasosenlaejecuacindeunainstruccinenMicroMIPS:...........................................................12
Diagramadebloquesdelprocesador:rutadedatossencillayunidaddecontrol.......................14

Implementacinysimulacindelosbloquesarchivoderegistro,multiplexoresyextensinde
signoenVHDL...................................................................................................................................15
ARCHIVODEREGISTROS...............................................................................................................15
1.
Definicin:.....................................................................................................................15
2.
Implementacin:...........................................................................................................15
3.
InstruccionesausarenVHDL:.......................................................................................16
4.
CdigodelcomponenteenVHDL.................................................................................17
5.
Bancodeprueba...........................................................................................................19
6.
Simulacin:....................................................................................................................21
MULTIPLEXOR................................................................................................................................22
1.
Definicin:.....................................................................................................................22
2.
Implementacin:...........................................................................................................22
3.
InstruccionesausarenVHDL:.......................................................................................22
4.
CdigodelComponenteenVHDL:................................................................................23
5.
Bancodepruebas:.........................................................................................................23
6.
Simulacin:....................................................................................................................25
EXTENSINDESIGNO...................................................................................................................26
1.
Definicin:.....................................................................................................................26
2.
Implementacin:...........................................................................................................26
3.
InstruccionesausarenVHDL:.......................................................................................26
4.
CdigodelcomponenteenVHDL:................................................................................27
5.
Bancodepruebas:.........................................................................................................27
6.
Simulacin:....................................................................................................................28

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ImplementacinysimulacindelaALUenVHDL............................................................................29
SUMADORTOTALDEUNBIT.........................................................................................................29
1.
Definicin:.....................................................................................................................29
2.
Implementacin:...........................................................................................................29
3.
InstruccionesausarenVHDL:.......................................................................................30
4.
CdigodelcomponenteenVHDL:................................................................................30
5.
Bancodeprueba:..........................................................................................................31
6.
Simulacin:....................................................................................................................32
SUMADORTOTALDE32BITS........................................................................................................33
1.
Definicin:.....................................................................................................................33
2.
Implementacin:...........................................................................................................33
3.
InstruccionesausarenVHDL:.......................................................................................33
4.
CdigodelcomponenteenVHDL:................................................................................35
5.
Bancodeprueba:..........................................................................................................36
6.
Simulacin:....................................................................................................................37

LaUnidadaritmticalgica...............................................................................................................38
ImplementacindelaALU............................................................................................................38
1.
Definicin:.....................................................................................................................38
2.
Implementacin:...........................................................................................................38
3.
InstruccionesausarenVHDL:.......................................................................................39
4.
CdigodelcomponenteenVHDL:................................................................................39
5.
Bancodeprueba:..........................................................................................................40
6.
Simulacin:....................................................................................................................42

Bloquedecontadordeprograma(PC)yelbloquequecalculalasiguientedireccin(NEXT
ADDRESS)..........................................................................................................................................43
PC(Contadordeprograma)..........................................................................................................43
1.
Definicin:.....................................................................................................................43
2.
Implementacin:...........................................................................................................43
3.
InstruccionesausarenVHDL:.......................................................................................43
4.
CdigodelcomponenteenVHDL:................................................................................44
5.
Bancodeprueba:..........................................................................................................44
6.
Simulacin:....................................................................................................................45
NEXTADDRESS(siguientedireccin)............................................................................................46

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

1.
2.
3.
4.
5.
6.

Definicin:.....................................................................................................................46
Implementacin:...........................................................................................................46
InstruccionesausarenVHDL:.......................................................................................46
CdigodelcomponenteenVHDL:................................................................................46
Bancodeprueba:..........................................................................................................48
Simulacin:....................................................................................................................50

Sntesisysimulacindelarutadedatos..........................................................................................52
Introduccin..................................................................................................................................52
1.
CdigodelcomponenteenVHDL:................................................................................52
2.
Bancodeprueba:..........................................................................................................57
3.
Simulacin.....................................................................................................................61

Derivacindelassealesdecontrol.................................................................................................62
ImplementacinysimulacinenVHDLdelaunidaddecontrol.Bloques:decodificadores,circuitos
combinacionales................................................................................................................................62
DecodificadordeInstrucciones1..................................................................................................65
1.
Definicin:.....................................................................................................................65
2.
Implementacin:...........................................................................................................65
3.
InstruccionesausarenVHDL:.......................................................................................65
4.
CdigodelcomponenteenVHDL:................................................................................65
5.
Bancodeprueba:..........................................................................................................66
6.
Simulacin.....................................................................................................................68
DecodificadordeInstrucciones2..................................................................................................69
1.
Definicin:.....................................................................................................................69
2.
Implementacin:...........................................................................................................69
3.
InstruccionesausarenVHDL:.......................................................................................69
4.
CdigodelcomponenteenVHDL:................................................................................69
5.
Bancodepruebas..........................................................................................................70
6.
Simulacin.....................................................................................................................72
1.
Definicion:.....................................................................................................................73
2.CdigodelcomponenteenVHDL.........................................................................................73
3.
Bancodeprueba...........................................................................................................75
4.
Simulacion.....................................................................................................................79

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

CONTROLUNIT..............................................................................................................................80
1.
Definicin:.....................................................................................................................80
2.
CdigoenVHDLdelcomponente.................................................................................80
3.
Bancodeprueba...........................................................................................................84

DatapathyUnidaddeControl......................................................................................................88
1.
CodigodelcomponenteenVHDL.................................................................................88
2.
Bancodepruebas..........................................................................................................92
3.
Simulacion.....................................................................................................................94

Procesador....................................................................................................................................96

UserConstraintsFile.....................................................................................................................98

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Tabladeilustraciones

Fig.1Representacindelasumaendiferentesniveles....................................................................9
Fig.2Setdeinstrucciones................................................................................................................10
Fig.3InstruccionestipoR................................................................................................................11
Fig.4InstruccionestipoI..................................................................................................................11
Fig.5InstruccionestipoJ.................................................................................................................11
Fig.6Resumendelostiposdeinstrucciones...................................................................................12
Fig.7Tipodeinstruccionesencuantoalaformadeejecucin.......................................................13
Fig.8Estructurageneraldeunprocesador......................................................................................14
Fig.9Estructuradeunarchivoderegistros......................................................................................15
Fig.10Simulacindelarchivoderegistros.......................................................................................21
Fig.11Multiplexor4x1......................................................................................................................22
Fig.12Simulacindelmultiplexor4x1.............................................................................................25
Fig.13Extensindesignodenam+nbits.......................................................................................26
Fig.14Simulacindelaextensindesigno......................................................................................28
Fig.15Tabladeverdadydiagramadebloquedeunsumadortotaldeunbit................................29
Fig.16Diagramaesquemticodeunsumadortotaldeunbit.........................................................29
Fig.17Simulacindeunsumadortotaldeunbit............................................................................32
Fig.18Diagramadebloquesdeunsumadortotalde32bits..........................................................33
Fig.19Diagramaesquemticodeunsumadortotalde32bits.......................................................33
Fig.20Simulacindeunsumadortotalde32bits...........................................................................37
Fig.21Diagramaesquemticodeunaunidadaritmticalgica(ALU)............................................38

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Fig.22SimulacindeunaALU..........................................................................................................42
Fig.23Digramadebloquedeuncontadordeprograma(PC)..........................................................43
Fig.24Simulacindeuncontadordeprograma(PC).......................................................................45
Fig.25DigramaesquemticodelbloqueNEXTADDRESS................................................................46
Fig.26SimulaciondelbloqueNEXTADDRES....................................................................................51
Fig.27Rutadedatosdeciclosencilla...............................................................................................52
Fig.28Simulacindelarutadedatossencilla.................................................................................61
Fig.29Cdigosdeoperacindelasinstrucciones............................................................................62
Fig.30Sealesdecontroldelarutadedatos..................................................................................63
Fig.31Identificacindelasinstrucciones.........................................................................................64
Fig.32SimulacindeIdecodificadordeinstrucciones1..................................................................68
Fig.33SimulacindeIdecodificadordeinstrucciones2..................................................................72
Fig.34SimulacindeIaslneasauxiliaresdelaunidaddecontrol..................................................79
Fig.35SimulacindeIaUnidaddeControl......................................................................................87

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Arquitectura del juego de instrucciones


Las instrucciones son las interfaces que permiten el uso de un microprocesador. Cuando deseamos construir
una aplicacin en base a un procesador (sea este un microprocesador o microcontrolador) lo que hacemos es
confeccionar un programa que ejecute ese dispositivo. Un programa es una secuencia de instrucciones
almacenados en la memoria del procesador.
Para construir un procesador es necesario estudiar el juego de instrucciones (ISA) que ejecutar el procesador.
Ms an, en algunas ocasiones es necesario construir el ISA. Conocer exactamente que es lo que hace el
procesador permitir identificar los bloques internos del dispositivo.
En la siguiente Fig. 1 se muestra una instruccin de suma entre dos nmeros (b, c) cuyo resultado es
almacenado en un tercer nmero (a). La operacin se efectua a diferentes niveles.

Fig.1Representacindelasumaendiferentesniveles.
Como se ve en la Fig. 1 la primera representacin es un enunciado en alto nivel de una operacin de suma y a
continuacin se puede apreciar la representacin de la misma instruccin en alto ensamblador. Como se puede
ver los nombres de las variables han sido reemplazados por registros internos del procesador. A ese conjunto
de registros internos que tiene el procesador se le llama archivo de registros. En este caso en particular se
toma el contenido del registro s2 (posicin 18) y s1 (posicin 17) se suma y se almacena en la direccin del
registro t8 (posicin 24).
La siguiente lnea de la Fig. 1 muestra la representacin binaria de dicha instruccin. Como se puede apreciar
la instruccin esta compuesta de 32 bits y se puede identificar campos dentro de esta instruccin. Salta a la

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

vista que hay tres campos de 5 bits cada uno para almacenar la direccin de los registos que almacenaran los
operandos y la respuesta. Tambin existen 6 bits para representar el cdigo de operacin de la instruccin y
hay 6 bits para el cdigo adicional de la instruccin. La combinacin del cdigo de operacin y el cdigo
adicional ayudan a identificar la instruccin que deber ejecutar el procesador. En la Fig. 1 tambin hay un
campo de bits que no usa esta instruccin y que puede ser obviado.
Por otro lado, los compiladores son programa que tomar las instrucciones en alto nivel y las transforman en
instrucciones ensamblador del procesador. Una vez que se tiene esas instrucciones se procede a generar los
cdigos binarios que finalmente ejecuta el procesador.
Para el presente curso se van a considerar las siguientes instrucciones:

Fig.2Setdeinstrucciones
A este juego de 22 instrucciones lo llamaremos MicroMIPS por ser un subconjunto de las instrucciones que
ejecutan los procesadores MIPS de arquitectura RISC y que ser el tema de la implementacin que
presentams en este curso. Ms adelante incluiremos instrucciones de corrimiento para observar como se les
puede adicionar ms instrucciones a ISA inicial.
Si tuviramos que clasificar las instrucciones obedeciendo a la forma como estn compuestas las
instrucciones a nivel de bits tendramos tres categoras que se muestran a continuacin:

10

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Fig.3InstruccionestipoR

InstruccionestipoR: Este tipo de instrucciones son aquellas que se realizan solo entre registros.
Tanto los operandos como la respuesta se almacenan en el archivo de registro del procesador. Como se puede
apreciar en la Fig. 3 las instrucciones de este tipo tienen seis campos: cdigo de operacin, registro fuente 1,
registro fuente 2, registro destino, cantidad de corrimiento y cdigo de extensin (o cdigo adicional). La
arquitectura de las instrucciones no indica que el archivo de registro deber tener 32 posiciones. Por otro lado
el cdigo de operacin trabaja en conjunto con el cdigo extendido para identificar la instruccin. Si el cdigo
de operacin es igual a cero entonces se procede a examinar el cdigo extendido para identificar la
instruccin. Si el cdigo de operacin es diferente de cero no hay necesidad de examinar el cdigo extendido.

Fig.4InstruccionestipoI

InstruccionestipoI: Las instrucciones se emplear para realizar operaciones entre un registro y un


valor constante que es parte de la instruccin. A este valor constante tambin se le conoce como valor literal o
inmediato de all el nombre de este tipo de instrucciones. Como se puede apreciar en la figura existen cuatro
campos: cdigo de operacin, registro fuente o base, registro destino o de data y valor inmediato (que puede
ser un literal o el desplazamiento de una direccin). A este tipo de instruccin pertenecen no solo las
instrucciones aritmticas y lgicas sino tambin las instrucciones de bifurcacin.

Fig.5InstruccionestipoJ

Instrucciones tipo J: Las instrucciones de salto se emplean para que el programa pueda saltar a
diferentes zonas del programa. Los saltos son incondicionales, esto es basta con conocer la siguiente direccin
de salto para que el procesador actualice el contador de programa (PC) y ejecute la instruccin que all se
encuentra. El contador de programa es un puntero a la direccin de la siguiente instruccin a ser ejecutada.
El procesador que vamos a implementar emplea 32 bits para las direcciones. Sin embargo en la Fig. 5 se

11

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

aprecia que solo hay 26 bits para expresar las direcciones. La pregunta natural es donde estn los otros seis
bits. Lo que sucede es que todas las instrucciones ocupan cuatro bytes por lo tanto el PC aumenta de cuatro en
cuatro por lo tanto los dos ltimos bits del PC son siempre ceros. Por otro lado los cuatro bits ms
significativos que no se ven se tomar de los cuatro bits ms significativos del actual PC.
Como he sealado todas las instrucciones ocupan cuatro bytes y claro cuando extraemos de la memoria una
instruccin (cuatro bytes) no conocemos que instruccin es. Lo primero que debemos hacer es examinar el
cdigo de operacin para establecer que tipo de instruccin es y a partir de eso poder accionar algn circuito
dentro del procesador. La siguiente Fig. 6 muestra todos los tipos de instrucciones. De esta manera se puede
observar que todas respetan el campo de cdigo de operacin a partir del cual luego podemos identificar los
dems campos de la instruccin.

Fig.6Resumendelostiposdeinstrucciones

PasosenlaejecuacindeunainstruccinenMicroMIPS:
Adems de los tipos de instruccione que se han detallado en el apartado anterior es necesario examinar como
es la ejecucin de una instruccin. Para ello se presenta la Fig. 7 que identifica cinco tipos de instrucciones en
cuanto a la forma de ejecucin:

12

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Fig.7Tipodeinstruccionesencuantoalaformadeejecucin
El nmero mximo de pasos es cinco y todas las instrucciones realizan al menos dos pasos o etapas. Las
etapas son las siguientes:
a) Bsqueda de la instruccin. En esta etapa lo que hace el procesador es ir a la posicin de memoria
indicada por el PC y extraer de all cuatro bytes en adelante. A continuacin incrementa el valor del
PC en una unidad.
b) Decodificacin. La etapa de decodificacin consisten en identificar el cdigo de operacin de la
instruccin y adems se procede a dividir la instruccin en campos de tal forma que luego se puedan
usar como lneas de control para acceder al archivo de registro o para indicar una direccin u offset
que finalmente identifique una posicin de memoria.
c)

Ejecucin en ALU. Esta etapa es la que acciona propiamente las lneas de control de unidad
aritmtica lgica para que se realice un clculo entre los operandos que estn presentes en la entrada
de la ALU.

13

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

d) Almacenamiento en memoria. Esta etapa esta reservada para aquella instruccin que requeire
almacenar el resultado la operacin en una posicin de memoria.
e) Almacenamiento en archivo de registros. En esta etapa lo que se hace es almacenar la respuesta en
uno de los archivos de registro del procesador. Las instrucciones tipo R son un ejemplo de
instrucciones que obedece a este comportamiento.

Diagramadebloquesdelprocesador:rutadedatossencillayunidad
decontrol
La Fig. 8 muestra la estructura general de un procesador. Bsicamente se divide en dos partes: la ruta de datos
y la unidad de control. La primera de la unidades est destinada a presentar los datos en una serie de etapas
que permita a una instruccin salir de la memoria del procesador (memoria cache) para ser ingresada a la
unidad de control. Esta unidad es la encargada de instrumentar los circuitos que estn presentes en la ruta de
datos. En si es la que determina que operacin es la que se hace. Desde luego que dependiendo del tipo de
instruccin existen bloques que no se emplean en la ejecucin de la instruccin.

Fig.8Estructurageneraldeunprocesador
Las siguientes secciones de este docuemnto discuten como se hace la implementacin de un procesador de
estas caractersticas.

14

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Implementacin y simulacin de los


bloques archivo de registro, multiplexores
y extensin de signo en VHDL
ARCHIVODEREGISTROS
1.

Definicin:

2.

Implementacin: Para la implementacion se asume

Un archivo de registro sirve para almacenar los valores de los registros del
microprocesador. Los archivos de registros almacenan la informacion que luego sera ejecutada por la
ALU. Por ello cuentan con dos canales o registros de salida que permite tener a la entrada de la ALU
el valor de dos registros a operar.
que el procesador tiene 32 registros y
cada uno de ellos tiene 32 bits. La siguiente Fig. 9 muestra cmo es la estructura de un archivo de
registros de estas caracteristicas.

Fig.9Estructuradeunarchivoderegistros
En el archivo de registro tenemos los buses: data_in, data_out_1 y data_out_2 con 32 bits. En tanto
que los buses: write_address, read_address_1 y read_address2 tienen cinco bits cada uno. El
funcionamiento es como sigue: en el bus read_address_1 se coloca una direccin de un archivo de
registros y el contenido de este estar presente en la salida data_out_1. Lo mismo sucede para el bus
read_address_2 y su salida data_out_2. Los buses write_address y data_in conjuntamente con la
linea write_enable permiten los ciclos de escritura en alguno de los archivos de registros. La lnea de
clk es para la activacin de los circuitos en un flanco de bajada.

15

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

3.

InstruccionesausarenVHDL:
a)

entity: (entidad) esta instruccin permite definir la interface del componente. Esto es las
lneas de entrada y de salida. Equivale a definir una caja negra con sus entradas y sus salidas.
Dentro de la instruccin se coloca la palabra reservada port y a continuacin el listado de las
entradas y salidas. Es necesario mencionar que las entradas y las salidas pueden ser lneas
simples o buses.
entity SUMADOR is
port(
A, B: in std_logic;
SUM: out std_logic;
CARRY: out std_logic );
end SUMADOR;

b)

Arquitecture:

(arquitectura) esta instruccin permite definir la funcin lgica que

colocamos dentro de la entidad. Aqu se definen las operaciones en base a las lneas de entrada
previamente definidas. Una vez que se calcula la funcin lgica los resultados son presentados
en las lneas de salida definidas en la entidad. Una entidady puede tener ms de una arquitectura.
En este curso que cada entidad tiene una sola arquitectura.
architecture RTL of HALFADDER is
begin
SUM
<= A xor B;
CARRY <= A and B;
end RTL;

c)

Signal:

Las seales sirven para almacenar clculos intermedios al momento de generar la

funcin lgica. Adems las seales permiten interconectar componentes; es decir permite
construcir componentes complejos en base a componente simples
d)

<=: Esta es la sentencia de asignacin en VHDL. Lo que se coloca a la izquierda de la sentencia


se asigna al valor que esta definido en la izquierda.
A <= B OR C;

16

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

e)

Process: Un proceso permite que las instrucciones que estn en su mbito se ejecuten de
forma secuencial. Ademas un proceso lleva una lista de parmatros conocida como la lista de
sensibilidad de tal foma que el proceso es ejecutado solo cuando existe u cambio en la lista de
sensibilidad

f)

if: instruccin de bifurcacin. Dependiendo de si la condicin es verdadera o falsa se ejecuta un


grupo de instrucciones.
if CONDITION then
-- sequential statements
else
-- sequential statements
end if;

g)

case: similar a instrucciones if anidadas. Todas las condiciones tienen igual prioridad. Las
opciones no debes sobreponerse y necesario definer todo el rango de posibilidades.
case

EXPRESSION

is

when VALUE_1 =>


-- sequential statements
when VALUE_2 | VALUE_3
=>
-- sequential statements

-- | = OR

when VALUE_4 to VALUE_N =>


-- sequential statements

-- to = range

when
others =>
-- sequential statements
end

4.

case ;

CdigodelcomponenteenVHDL:

---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity reg_file_32_bits is
port (
write_enable: in STD_LOGIC;--Activar la escritura del registro
clk: in STD_LOGIC;--Clock
read_addr_1: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 1

17

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

read_addr_2: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 2


write_addr: in STD_LOGIC_VECTOR(4 downto 0);--direccion de escritura
data_in: in STD_LOGIC_VECTOR(31 downto 0);--Dato de entrada
data_out_1: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la
direccion 1
data_out_2: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la
direccion 2
--Muestreando el registro para ver los
REG_T0: out STD_LOGIC_VECTOR(31 downto
REG_T1: out STD_LOGIC_VECTOR(31 downto
REG_T3: out STD_LOGIC_VECTOR(31 downto
REG_T4: out STD_LOGIC_VECTOR(31 downto
REG_T5: out STD_LOGIC_VECTOR(31 downto

valores de fibonacci
0);--previos de la serie de fibnacci
0);--previos de la serie de fibnacci
0);--aqui vere la serie de fibonacci
0);--aqui vere el corrimiento a la izquierda
0)--aqui vere el corrimiento a la derecha

);
end reg_file_32_bits;
architecture Behavioral of reg_file_32_bits is
-- INTERNAL REGISTERS.
signal REG00: STD_LOGIC_VECTOR(31 downto 0):=x"00000000";
signal REG01: STD_LOGIC_VECTOR(31 downto 0):=x"00000000";
--completar!!
signal REG31: STD_LOGIC_VECTOR(31 downto 0):=x"00000000";
begin
REG_T0
REG_T1
REG_T3
REG_T4
REG_T5

<= REG08; -- t0 f(n-2)


<= REG09; -- t1 f(n-1)
<= REG15; -- t3 f(n)
<= REG12;
<= REG13;
begin
if (write_enable = '1' and RISING_EDGE(clk)) then --Si esta activa la
escritura en el registro (write)
case write_addr is --Direccion de escritura
when "00000" =>
REG00 <= data_in;
--completar!!
--REG31 <= data_in;
when others =>
REG31 <= data_in; --ERRFLAG <= '1';
end case;
end if;
end process;
------------------------------------------ BUSQUEDA DE DATOS DESDE LOS REGISTROS
-- Esto toma datos desde uno de los
-- registros internos y lo escribe
-- en el bus de salida apropiado.
------------------------------------------ read_addr_1
data_out_1 <= REG00 when read_addr_1 = "00000" else

18

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

REG01 when read_addr_1 = "00001" else


--completar!!
REG31 when read_addr_1 = "11111" else REG00;
-- read_addr_2
data_out_2 <= REG00 when read_addr_2 = "00000" else
REG01 when read_addr_2 = "00001" else
--completar!!
REG31 when read_addr_2 = "11111" else REG00;
-- END REGISTER FETCH

end Behavioral;

5.

Bancodeprueba:

-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY reg_file_32_bits_tb IS
END reg_file_32_bits_tb;
ARCHITECTURE behavior OF reg_file_32_bits_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT reg_file_32_bits
PORT(
write_enable : IN std_logic;
clk : IN std_logic;
read_addr_1 : IN std_logic_vector(4 downto 0);
read_addr_2 : IN std_logic_vector(4 downto 0);
write_addr : IN std_logic_vector(4 downto 0);
data_in : IN std_logic_vector(31 downto 0);
data_out_1 : OUT std_logic_vector(31 downto 0);
data_out_2 : OUT std_logic_vector(31 downto 0);
REG_T0 : OUT std_logic_vector(31 downto 0);
REG_T1 : OUT std_logic_vector(31 downto 0);
REG_T3 : OUT std_logic_vector(31 downto 0);
REG_T4 : OUT std_logic_vector(31 downto 0);
REG_T5 : OUT std_logic_vector(31 downto 0)
);
END COMPONENT;
--Inputs
signal write_enable : std_logic := '0';
signal clk : std_logic := '0';
signal read_addr_1 : std_logic_vector(4 downto 0) := (others => '0');
signal read_addr_2 : std_logic_vector(4 downto 0) := (others => '0');
signal write_addr : std_logic_vector(4 downto 0) := (others => '0');
signal data_in : std_logic_vector(31 downto 0) := (others => '0');

19

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--Outputs
signal data_out_1 : std_logic_vector(31 downto 0);
signal data_out_2 : std_logic_vector(31 downto 0);
signal REG_T0 : std_logic_vector(31 downto 0);
signal REG_T1 : std_logic_vector(31 downto 0);
signal REG_T3 : std_logic_vector(31 downto 0);
signal REG_T4 : std_logic_vector(31 downto 0);
signal REG_T5 : std_logic_vector(31 downto 0);
-- Clock period definitions
constant clk_period : time := 1ns;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: reg_file_32_bits PORT MAP (
write_enable => write_enable,
clk => clk,
read_addr_1 => read_addr_1,
read_addr_2 => read_addr_2,
write_addr => write_addr,
data_in => data_in,
data_out_1 => data_out_1,
data_out_2 => data_out_2,
REG_T0 => REG_T0,
REG_T1 => REG_T1,
REG_T3 => REG_T3,
REG_T4 => REG_T4,
REG_T5 => REG_T5
);
Escritura : Process
Begin
write_enable <= '0';
wait for CLK_PERIOD;
write_enable <= '1';
wait for CLK_PERIOD * 256; -- will wait forever
end Process;
clock : Process
Begin
clk <= '1';
wait for CLK_PERIOD;
clk <= '0';
wait for CLK_PERIOD;
end Process;
Data : Process
Begin
data_in <="00000000000000000000000000000001";
wait for CLK_PERIOD*4;
data_in <="00000000000000000000000000000010";
end Process;
Clocks : Process
Begin

20

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

wait for CLK_PERIOD * 2;


write_addr <= "00000";
read_addr_1 <= "00000";
read_addr_2 <= "00001";
wait for CLK_PERIOD * 8;
write_addr <= "00001";
end Process;
END;

6.

Simulacin:

Fig.10Simulacindelarchivoderegistros

21

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

MULTIPLEXOR
1.

Definicin:

Un multiplexor (Fig. 11) es un dispositivo electrnico que se comporta como un


conmutador. Posee 2n canales de entrada, un solo canal de salida y n lneas de seleccin. El valor
presente en las lneas de seleccin determina que canal de entrada estar en la salida.

Fig.11Multiplexor4x1
2.

Implementacin: Para el procesador es necesaria la implementacin de un multiplexor de 4 a


1. Donde cada uno de los canales es de 32 bits. El segundo canal (canal 1) tiene una caracterstica
especial. Cuando el dato que se aplica es positivo (esto es el bit de mayor peso es cero) la salida del
multiplexor es todo ceros. Caso contrario el canal de salida presentar 32 unos.

3.

InstruccionesausarenVHDL:
a)

if: instruccin de bifurcacin. Dependiendo de si la condicin es verdadera o falsa se ejecuta un


grupo de instrucciones.
if CONDITION then
-- sequential statements
else
-- sequential statements
end if;

b)

case: similar a instrucciones if anidadas. Todas las condiciones tienen igual prioridad. Las
opciones no debes sobreponerse y necesario definer todo el rango de posibilidades.
case

EXPRESSION

is

when VALUE_1 =>


-- sequential statements

22

when VALUE_2 | VALUE_3


=>
-- sequential statements

-- | = OR

when

-- to = range

VALUE_4 to VALUE_N

=>

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

-- sequential statements
when
others =>
-- sequential statements
end

4.

case ;

CdigodelComponenteenVHDL:
-------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity mux_alu_4_32_bits is
Port ( mux_in_0 : in STD_LOGIC_VECTOR (31 downto 0);
mux_in_1 : in STD_LOGIC_VECTOR (31 downto 0);
mux_in_2 : in STD_LOGIC_VECTOR (31 downto 0);
mux_in_3 : in STD_LOGIC_VECTOR (31 downto 0);
function_class : in STD_LOGIC_VECTOR (1 downto 0);
mux_out : out STD_LOGIC_VECTOR (31 downto 0));
end mux_alu_4_32_bits;
architecture Behavioral of mux_alu_4_32_bits is
begin
Process(mux_in_0, mux_in_1, mux_in_2, mux_in_3, function_class)
begin
case function_class is
when "00" =>
mux_out<=mux_in_0;
when "01" =>
-- completar!!!
when others =>
mux_out<=mux_in_3;
end case;
end Process;
end Behavioral;

5.

Bancodepruebas:
---------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;

23

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY mux_alu_4_32_bits_tb IS
END mux_alu_4_32_bits_tb;
ARCHITECTURE behavior OF mux_alu_4_32_bits_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT mux_alu_4_32_bits
PORT(
mux_in_0 : IN std_logic_vector(31 downto 0);
mux_in_1 : IN std_logic_vector(31 downto 0);
mux_in_2 : IN std_logic_vector(31 downto 0);
mux_in_3 : IN std_logic_vector(31 downto 0);
function_class : IN std_logic_vector(1 downto 0);
mux_out : OUT std_logic_vector(31 downto 0)
);
END COMPONENT;

--Inputs
signal mux_in_0 : std_logic_vector(31 downto 0) := (others => '0');
signal mux_in_1 : std_logic_vector(31 downto 0) := (others => '0');
signal mux_in_2 : std_logic_vector(31 downto 0) := (others => '0');
signal mux_in_3 : std_logic_vector(31 downto 0) := (others => '0');
signal function_class : std_logic_vector(1 downto 0) := (others => '0');
--Outputs
signal mux_out : std_logic_vector(31 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: mux_alu_4_32_bits PORT MAP (
mux_in_0 => mux_in_0,
mux_in_1 => mux_in_1,
mux_in_2 => mux_in_2,
mux_in_3 => mux_in_3,
function_class => function_class,
mux_out => mux_out
);
Mux_alu: Process
begin
mux_in_0<="00000000000000000000000000000001";
-- completar!!
mux_in_3<="00000000000000000000000000000100";
function_class<="00";
wait for 10 ns;
mux_in_0<="00000000000000000000000000000001";
--completar!!
mux_in_3<="00000000000000000000000000000100";
function_class<="01";

24

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

wait for 10 ns;


mux_in_0<="00000000000000000000000000000001";
--completar!!
mux_in_3<="00000000000000000000000000000100";
function_class<="10";
wait for 10 ns;
mux_in_0<="00000000000000000000000000000001";
--completar!!
mux_in_3<="00000000000000000000000000000100";
function_class<="11";
wait for 10 ns;
end Process;
END;

6.

Simulacin:

Fig.12Simulacindelmultiplexor4x1

25

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

EXTENSINDESIGNO
1.

Definicin: Un componente que hace la extensin de signo (Fig. 13) se caracteriza por tomar un
nmero binario expresado en n bits con signo y colocarlo en m+n bits. Para realizar dicho trabajo es
necesario examinar el bit de mayor peso del nmero. Si el signo del numero expresado en n bits es
positivo el rellenado de los m bits es ceros en tanto que si el bit de mayor peso es uno el rellenado de
los m bits es unos.

Fig.13Extensindesignodenam+nbits

2.

Implementacin: Para el procesador se proceder a hacer la extensin de signo de nmeros


de 16 bits a 32 bits. Este componente sirve para extender los bits de los valores inmediatos que
vienen en las instrucciones tipo I.

3.

InstruccionesausarenVHDL:
a)

If: instruccin de bifurcacin. Dependiendo de si la condicin es verdadera o falsa se ejecuta un


grupo de instrucciones.
if CONDITION then
-- sequential statements
else
-- sequential statements
end if;

b)

&:instruccin para unir o concatenr bits. La concatenacin solo se permite en la parte derecha
de una operacin de asignacin <=.
architecture EXAMPLE_1 of CONCATENATION is
signal BYTE
: bit_vector (7 downto 0);
signal A_BUS, B_BUS : bit_vector (3 downto 0);
begin
BYTE
<= A_BUS & B_BUS;
end EXAMPLE;

26

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

4.

CdigodelcomponenteenVHDL:
----------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity se_main is
Port ( se_in : in STD_LOGIC_VECTOR (15 downto 0);
se_out : out STD_LOGIC_VECTOR (31 downto 0));
end se_main;
architecture Behavioral of se_main is
begin
Process(se_in)
begin
if(se_in(15)='0') then --verificamos si es un numero positivo
se_out<= -- completar!!
else --Entonces debe de ser 1
se_out<= -- completar!!
end if;
end Process;
end Behavioral;

5.

Bancodepruebas:
---------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY se_main_tb IS
END se_main_tb;
ARCHITECTURE behavior OF se_main_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT se_main
PORT(
se_in : IN std_logic_vector(15 downto 0);
se_out : OUT std_logic_vector(31 downto 0)

27

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

);
END COMPONENT;
--Inputs
signal se_in : std_logic_vector(15 downto 0) := (others => '0');
--Outputs
signal se_out : std_logic_vector(31 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: se_main PORT MAP (
se_in => se_in,
se_out => se_out
);
SE: Process
begin
se_in<="0000000000000001";
wait for 10 ns;
--completar!!
end Process;
END;

6.

Simulacin:

Fig.14Simulacindelaextensindesigno

28

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Implementacin y simulacin de la ALU en


VHDL
SUMADORTOTALDEUNBIT
1.

Definicin: Un sumador total de un bit es un bloque combinacional que es capaz de sumar tres
entradas binarias. Las entradas se definen como x, y, cin. Los bits a sumar son x, y; en tanto
que cin es el acarreo de entrada. Las lneas de salida del sumador total de un bit son s y cout que
representan la suma y el acarreo de salida respectivamente. La Fig. 15 presenta la tabla de verdad y
el diagrama de bloques de un sumador total de un bit.

Fig.15Tabladeverdadydiagramadebloquedeunsumadortotaldeunbit
2.

Implementacin: La implementacin de un sumador ser de acuerdo al diagrama lgico de la


Fig. 16 y que responde a la tabla de verdad del componente. La implementacin de un dispositivo de
este tipo posibilitar la contruccin de un sumador total de 32 bits.

Fig.16Diagramaesquemticodeunsumadortotaldeunbit

29

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

3.

InstruccionesausarenVHDL:
a)

<=: la instruccin sirve para asignar valores a variables que pueden ser bits o arreglos de bits.
Si la asignacin es de bit se debe usar las comillas simples. Si es vector se deben usar las
comillas dobles. Tambien es posible definir el tipo de sistema anteponiendo las letras b o x
segn el valor este expresado en binario o en hexadecimal.
architecture EXAMPLE of ASSIGNMENT is
signal Z_BUS
: bit_vector (3 downto 0);
signal BIG_BUS : bit_vector (15 downto 0);
begin
-- legal
Z_BUS(3)
Z_BUS
Z_BUS
Z_BUS
Z_BUS
BIG_BUS

assignments:
<= 1;
<= 1100;
<= b1100;
<= xc;
<= XC;
<= B0000_0001_0010_0011;

end EXAMPLE;

b)

Operadoreslgicos: VHDL implementa los operadores lgicos bsicos como son not,
and, or, nor, nand, xor y xnor. La mayor prioridad lo tiene el operador not en tanto que los
dems tienen la misma prioridad. Se recomienda el uso de parntesis para indicar claramente la
expresin a procesar.
entity LOGIC_OP is
port (A, B, C, D : in
bit;
Z1:
out bit;
EQUAL :out boolean);
end LOGIC_OP;
architecture EXAMPLE of LOGIC_OP is
begin
Z1 <= A and (B or (not C xor D)));
EQUAL <= A xor B;
-- wrong
end EXAMPLE;

4.

CdigodelcomponenteenVHDL:
----------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

30

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

---- Uncomment the following library declaration if instantiating


---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity fa_1_bit
Port ( xi :
yi :
ci :
si :
co :
end fa_1_bit;

is
in STD_LOGIC;--entrada de 1 bit
in STD_LOGIC;--entrada de 1 bit
in STD_LOGIC;--acarreo de entrada
out STD_LOGIC;--suma de xi y yi
out STD_LOGIC);--acarrei de salida

architecture Behavioral of fa_1_bit is


begin
si<= xi xor yi xor ci; -- calculamos la suma de salida
-- completar!!
end Behavioral;

5.

Bancodeprueba:
----------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY fa_1_bit_tb IS
END fa_1_bit_tb;
ARCHITECTURE behavior OF fa_1_bit_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT fa_1_bit
PORT(
xi : IN std_logic;
yi : IN std_logic;
ci : IN std_logic;
si : OUT std_logic;
co : OUT std_logic
);
END COMPONENT;

--Inputs
signal xi : std_logic := '0';
signal yi : std_logic := '0';
signal ci : std_logic := '0';
--Outputs
signal si : std_logic;
signal co : std_logic;

31

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: fa_1_bit PORT MAP (
xi => xi,
yi => yi,
ci => ci,
si => si,
co => co
);
xi_signal: Process
begin
xi<=not xi;
wait for 1 ns;
end Process;
yi_signal: Process
begin
yi<=not yi;
--completar!!
end process;
ci_signal: Process
begin
ci<=not ci;
--completar!!
end process;
END;

6. Simulacin:

Fig.17Simulacindeunsumadortotaldeunbit

32

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

SUMADORTOTALDE32BITS
1. Definicin:

Un sumador total de 32 bits (Fig. 18) es un bloque lgico capaz de sumar dos
nmeros binarios de 32 bits. Al igual que un sumador total de un bit tiene un acarreo de entrada y un
acarreo de salida.

Fig.18Diagramadebloquesdeunsumadortotalde32bits

2.

Implementacin:

Para construir sumadores de 32,64, etc bits es conveniente emplear


sumadores con clculo de acarreo adelantado porque son veloces. Ejemplo de este tipo de sumadores
son los sumadores con redes de acarreo Brent-Kung. Sin embargo en este caso la implementacin
ser en base a sumadores de bit colocados en cascada como se muestra en la Fig. 19.

Fig.19Diagramaesquemticodeunsumadortotalde32bits

Note que el sumador a implementar no tiene acarreo de salida Cout.


3.

InstruccionesausarenVHDL:

33

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

a)

component:

la instruccin component se usa para declarar componentes dentro de

componentes, es decir permite la construccin de componente ms complejos en base a


componentes ms simples. La declaracin del componente se debe realizar antes de la palabra
reservada begin que se encuentra dentro de la seccin de la arquitectura del componente ms
complejo. Tanto el componente simple como el componente complejo deben ser parte del
mismo proyecto y la declaracin del componente simple debe ser exactamente igual a la
inclusin que se hace en el componente complejo.
entity FULLADDER is
port (A,B, CARRY_IN: in
bit;
SUM, CARRY:
out bit);
end FULLADDER;
architecture STRUCT of FULLADDER is
signal W_SUM, W_CARRY1, W_CARRY2 : bit;
component HALFADDER
port (A, B :in
bit;
SUM, CARRY : out bit);
end component;
component ORGATE
port (A, B : in
bit;
RES : out bit);
end component;

b) port map:

Una vez que el component se sido declarado se procede a crear una o ms

instancias (copias) de dicho componente (simple) dentro del componente ms complejo. Para
ello la sentencia port map nos permite crear multiples instancias. Para distinguir una instancia
de la otra es necesario asignar una etiqueta a cada una (desde luego que el nombre de la etiqueta
no puede ser una palabra reservada o un identificador que se haya usado antes para definir una
lnea de entrada/salida del componente). La ubicacin de las instancias es dentro del cuerpo de
la arquitectura esto es despus de la sentencia begin. Dentro del port map es necesario
realizar las conexiones que requieren los componentes simples para generar un componente ms
complejo. Observe el siguiente ejemplo:

architecture structure of latch is


component nor_gate
port (a,b: in bit;
c: out bit);

34

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

end component;
begin
n1: nor_gate
port map (a=>r,b=>nq,c=>q);
n2: nor_gate
port map (a=>s,b=>q ,c=>nq);
end structure;

4.

CdigodelcomponenteenVHDL:
---------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity adder_alu_32_bits is
Port ( x : in STD_LOGIC_VECTOR (31 downto 0);
y : in STD_LOGIC_VECTOR (31 downto 0);
cin : in STD_LOGIC;
s : out STD_LOGIC_VECTOR (31 downto 0));
end adder_alu_32_bits;
architecture Behavioral of adder_alu_32_bits is
component fa_1_bit
Port (
xi : in STD_LOGIC;
yi : in STD_LOGIC;
ci : in STD_LOGIC;
si : out STD_LOGIC;
co : out STD_LOGIC);
end component;
signal sig:std_logic_vector(30 downto 0);
begin
adder_0:fa_1_bit
Port map( xi =>x(0),
-yi =>y(0),
-ci =>cin ,
-si =>s(0),
-co =>sig(0));-adder_1:fa_1_bit
Port map( xi =>x(1),
yi =>y(1),
ci =>sig(0),
si =>s(1),
co =>sig(1));

entrada
entrada
acarreo
suma de
acarreo

xi
yi
de
xi
de

del sumador de 1 bit


del sumador de 1 bit
entrada de 1 bit
y yi de 1 bit
salida de 1 bit

--completar!!
adder_31:fa_1_bit
Port map( xi =>x(31),

35

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

yi =>y(31),
ci =>sig(30),
si =>s(31));
end Behavioral;

5.

Bancodeprueba:
---------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY adder_alu_32_bits_tb IS
END adder_alu_32_bits_tb;
ARCHITECTURE behavior OF adder_alu_32_bits_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT adder_alu_32_bits
PORT(
x : IN std_logic_vector(31 downto 0);
y : IN std_logic_vector(31 downto 0);
cin : IN std_logic;
s : OUT std_logic_vector(31 downto 0)
);
END COMPONENT;

--Inputs
signal x : std_logic_vector(31 downto 0) := (others => '0');
signal y : std_logic_vector(31 downto 0) := (others => '0');
signal cin : std_logic := '0';
--Outputs
signal s : std_logic_vector(31 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: adder_alu_32_bits PORT MAP (
x => x,
y => y,
cin => cin,
s => s
);
adder: Process
begin
--completar con un par de sumas!!
end Process;

36

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

END;

6.

Simulacin:

Fig.20Simulacindeunsumadortotalde32bits

37

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

La Unidad aritmtica lgica


ImplementacindelaALU
1.

Definicin:

2.

Implementacin: Para la implementacin se ha empleado el diagrama que se muestra en la

La unidad aritmtica lgica del procesador es la encargada de realizar las


operaciones de suma/resta, logicas y de corrimiento. Las operaciones a realizar dependen de las
instrucciones que ingresan al procesador. Cada instruccin lleva en su interior un cdigo de
operacin (y algunas un cdigo de operacin extendido) que es identificado por la unidad de control
del procesador. Una vez identificada la instruccin la unidad de control instrumenta la ALU para
ejecutar la operacin que ha sido identificada.
Fig. 21.

Fig.21Diagramaesquemticodeunaunidadaritmticalgica(ALU)

La unidad aritmtico lgica consta de tres sub secciones que realizan operaciones en paralelo. Existe
en la parte superior de la figura un bloque llamado Shiter que se encarga de realizar las
operaciones de corrimiento. En la parte central se encuentra el bloque Adder que realiza las
operaciones de suma y resta. Finalmente en la parte inferior de la figura esta presente el bloque
Logic Unit que realiza las operaciones lgicas. Si bien es cierto todo el tiempo se calculan tres
operaciones solo aparece una de ellas en la salida S. Eso se debe al multiplexor ubicado a la salida de

38

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

la ALU. En la implementacin se usaran los bloques que se muestran en el diagrama anterior.


Algunos de ellos han sido desarrollados en las secciones anteriores de este documento.
3.

4.

InstruccionesausarenVHDL: No figuran nuevas instrucciones.

CdigodelcomponenteenVHDL:
----------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity alu is
Port ( x : in STD_LOGIC_VECTOR (31 downto 0);
y : in STD_LOGIC_VECTOR (31 downto 0);
constant_amount : in STD_LOGIC_VECTOR (4 downto 0);
constant_var : in STD_LOGIC;
function_class : in STD_LOGIC_VECTOR (1 downto 0);
logic_function : in STD_LOGIC_VECTOR (1 downto 0);
add_sub : in STD_LOGIC;
shift_function : in STD_LOGIC_VECTOR (1 downto 0);
s : out STD_LOGIC_VECTOR (31 downto 0));
end alu;
architecture Behavioral of alu is
component adder_alu_32_bits
--completar!!
component xor_alu
--completar!!
component logic_unit_alu
--completar!!
component shifter_alu
--completar!!
component mux_alu_4_32_bits
--completar!!
component mux_shifter
--completar!!
signal sig0:STD_LOGIC_VECTOR (31 downto 0);
signal sig1:STD_LOGIC_VECTOR (31 downto 0);
signal sig2:STD_LOGIC_VECTOR (31 downto 0);

39

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

signal sig3:STD_LOGIC_VECTOR (4 downto 0);


signal sig4:STD_LOGIC_VECTOR (31 downto 0);
begin
adder_alu_32_bits_1:adder_alu_32_bits
PORT MAP (
x =>x,
y =>sig1,
cin =>add_sub,
s =>sig0--adder con mux
);
xor_alu_1:xor_alu
PORT MAP (
xor_in =>y,
xor_in_add_sub =>add_sub,
xor_out =>sig1--xor con adder
);
logic_unit_alu_1:logic_unit_alu
PORT MAP (
lu_in_1 =>x,
lu_in_2 =>y,
logic_function_in =>logic_function,
lu_out =>sig2--logic_unit con mux
);
shifter_alu_1:shifter_alu
PORT MAP (
--completar!!
);
mux_alu_4_32_bits_1:mux_alu_4_32_bits
PORT MAP (
mux_in_0 =>sig4,
mux_in_1 =>sig0,
mux_in_2 =>sig0,
mux_in_3 =>sig2,
function_class =>function_class,
mux_out =>s
);
mux_shifter_1:mux_shifter
PORT MAP(
constant_amount_in =>constant_amount,
variable_amount_in =>x(4 downto 0),
amount_out =>sig3,--shifter con mux
constant_var_in =>constant_var
);
end Behavioral;

5.

Bancodeprueba:
-----------------------------------------------------------------------------

40

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY alu_tb_vhd IS
END alu_tb_vhd;
ARCHITECTURE behavior OF alu_tb_vhd IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT alu
PORT(
x : IN std_logic_vector(31 downto 0);
y : IN std_logic_vector(31 downto 0);
constant_amount : IN std_logic_vector(4 downto 0);
constant_var : IN std_logic;
function_class : IN std_logic_vector(1 downto 0);
logic_function : IN std_logic_vector(1 downto 0);
add_sub : IN std_logic;
shift_function : IN std_logic_vector(1 downto 0);
s : OUT std_logic_vector(31 downto 0)
);
END COMPONENT;
--Inputs
SIGNAL constant_var : std_logic := '0';
SIGNAL add_sub : std_logic := '0';
SIGNAL x : std_logic_vector(31 downto 0) := (others=>'0');
SIGNAL y : std_logic_vector(31 downto 0) := (others=>'0');
SIGNAL constant_amount : std_logic_vector(4 downto 0) :=
(others=>'0');
SIGNAL function_class : std_logic_vector(1 downto 0) :=
(others=>'0');
SIGNAL logic_function : std_logic_vector(1 downto 0) :=
(others=>'0');
SIGNAL shift_function : std_logic_vector(1 downto 0) :=
(others=>'0');
--Outputs
SIGNAL s :

std_logic_vector(31 downto 0);

BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: alu PORT MAP(
x => x,
y => y,
constant_amount => constant_amount,
constant_var => constant_var,
function_class => function_class,
logic_function => logic_function,
add_sub => add_sub,
shift_function => shift_function,
s => s
);

41

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ALU_test:Process
Begin
x<="00000000000000000000000000011111";
y<="00000000000000000000000000000001";
constant_amount<="00011";
constant_var<='1';--Con '0' deja pasar constant amount // con '1' deja pasar
variable amount
function_class<="11"; --Mux salida // 00 corrimiento // 01 set less // 10
aritmethic // 11 logic
logic_function<="00"; -- 00 AND // 01 OR // 10 XOR // 11 NOR
add_sub<='0';-- '0' suma // '1' resta
shift_function<="01";-- 00 no corrimiento // 01 corrimiento izquierda // 10
corrimiento derecha // 11 corrimiento artimetico derecha
wait for 10 ns;
x<="00000000000000000000000000010001";
y<="00000000000000000000000000001010";
constant_amount<="00010";
constant_var<='1';
function_class<="11";
logic_function<="00";
add_sub<='0';
shift_function<="01";
wait for 10 ns;
end Process;
END;

6.

Simulacin:

Fig.22SimulacindeunaALU

42

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Bloque de contador de programa (PC) y el


bloque que calcula la siguiente direccin
(NEXT ADDRESS).
PC(Contadordeprograma)
1. Definicin: Un contador de programa es conjunto de n flip-flop cuya funcin es almacenar la
direccin de la siguiente instruccin a ser ejecutada por el microprocesador. El contador de programa
se debe actualizar despus de ejecutar una instruccin. El valor que almacena no es necesariamente
secuencial; esto es no va de una direccin n a una direccin n+1. Las instrucciones de salto y
bifurcacin hacen que el valor almacenado por el contador de programa cambia de forma no
secuencial. La Fig. 23 muestra el diagrama de bloque de un PC.

Fig.23Digramadebloquedeuncontadordeprograma(PC)

2.

Implementacin: Para llevar a cabo el contador de programa se consider un contador de


programa de 30 bits. El funcionamiento es similar a un conjunto de flip-flop tipo D en los cuales las
lneas de clock (clk) estn conectadas a un solo pin como se muestra en la Fig. 23. El contador de
programa tiene 30 bits debido a que procesa las instrucciones en grupos de cuatro bytes. Es por eso
que si bien es cierto tien 30 bits es capaz de direccionar 32 bits de direcciones. El PC se inicia con el
valor cero.

3.

InstruccionesausarenVHDL:
a)

event: esta no es una instruccin sino que es un atributo que puede ser asociado a datos en
VHDL. El atributo se emplea en la construccin de circuitos secuenciales que tiene que lidear
con la deteccin de flancos de sbida o bajada. Para ello el atributo event permite conocer que
ha habido una transicin de 1-lgico a 0-lgico o viceversa. El atributo en combinacin con el
valor del dato permite conocer si aparecin un flanco como se muestra a continuacin:

43

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

if(clkevent AND clk =1)


if(clkevent AND clk =1)

--- flanco de subida


--- flanco de subida

4.

CdigodelcomponenteenVHDL:
--------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity Pc is
Port ( pc_in : in STD_LOGIC_VECTOR (29 downto 0);
clk : in STD_LOGIC;
pc_out : out STD_LOGIC_VECTOR (29 downto 0));
end Pc;
architecture Behavioral of Pc is
signal sig0:std_logic_vector(29 downto 0):="000000000000000000000000000000";
begin
Process(pc_in,clk)
begin
if (clk'event and clk='0') then -- detecto un flanco de bajada
sig0<=pc_in; --muestreo la entrada
end if;
end Process;
pc_out<=sig0; -- asigno el valor del muestro a la salida
end Behavioral;

5.

Bancodeprueba:
----------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY pc_tb IS
END pc_tb;
ARCHITECTURE behavior OF pc_tb IS

44

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

-- Component Declaration for the Unit Under Test (UUT)


COMPONENT Pc
PORT(
pc_in : IN std_logic_vector(29 downto 0);
clk : IN std_logic;
pc_out : OUT std_logic_vector(29 downto 0)
);
END COMPONENT;
--Inputs
signal pc_in : std_logic_vector(29 downto 0) := (others => '0');
signal clk : std_logic := '0';
--Outputs
signal pc_out : std_logic_vector(29 downto 0);
-- Clock period definitions
constant clk_period : time := 1us;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: Pc PORT MAP (
pc_in => pc_in,
clk => clk,
pc_out => pc_out
);
PC_test:Process
begin
pc_in<="000000000000000000000000000001";
clk<=not clk;
wait for 10 ns;
end Process;
END;

6.

Simulacin:

Fig.24Simulacindeuncontadordeprograma(PC)

45

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

NEXTADDRESS(siguientedireccin)
1.

Definicin: El bloque NEXT ADDRESS es necesario en el procesador para realizar el clculo


de la direccin de la siguiente instruccin a ser ejecutada en un programa. Las entradas al bloque
NEXT ADDRESS son el PC actual, jta (la direccin de salto), el contenido de los registros
direccionados por los registros rt y rs. Cuando no hay instrucciones de salta o bifurcacin el
comportamiento de este bloque es simple ya que incrementa el valor del PC en 1. Sin embargo
cuando se presentan instrucciones de salto bifurcacin entonces es necesario evaluar los contenidos
de los registros direccionados por rs y rt para comprobar si una relacin de desigualdad se cumple.
De ser este el caso se carga un nuevo PC. Caso contrario PC=PC+1.

2.

Implementacin: La implemementacin del bloque se realizar siguiendo el diagrama de la


Fig. 23.

Fig.25DigramaesquemticodelbloqueNEXTADDRESS

En el caso de las instrucciones distintas a las de salto y bifurcacin, NEXT ADDRESS incrementa el
valor del PC en 1 haciendo uso de un bloque de sumadores de 30 bits (recordar que cada instruccin
en memoria ocupa cuatro bytes por lo que los dos ltimos bits son siempre ceros). Para para poder
calcular la direccin siguiente de una instruccin de bifurcacin se debe previamente realizar la
verificacin de condicin de bifurcacin. Esto es realizado por el bloque BRANCH CONDITION
CHECKER que presenta a su salida uno en el caso que la condicin sea satisfecha, caso contrario
presenta el valor cero con lo cual la direccin siguiente ser PC+1. Si la condicin de bifurcacin es
satisfecha se debe extender el signo del valor inmediato contenido en imm y de esta manera se forma
la direccin hacia donde se realizar la bifurcacin.
3.

InstruccionesausarenVHDL:No aplica

4.

CdigodelcomponenteenVHDL:

46

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

---------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity next_address is
Port ( na_rt : in STD_LOGIC_VECTOR (31 downto 0);
na_rs : in STD_LOGIC_VECTOR (31 downto 0);
na_PC_31_2 : in STD_LOGIC_VECTOR (29 downto 0);
na_jta : in STD_LOGIC_VECTOR (25 downto 0);
na_syscalladdr : in STD_LOGIC_VECTOR (29 downto 0);
na_BrType : in STD_LOGIC_VECTOR (1 downto 0);
na_PCSrc : in STD_LOGIC_VECTOR (1 downto 0);
na_NextPC : out STD_LOGIC_VECTOR (29 downto 0);
na_IncrPC: out STD_LOGIC_VECTOR (29 downto 0));
end next_address;
architecture Behavioral of next_address is
component mux_4_30_bits
Port (
mux_in_0 : in STD_LOGIC_VECTOR (29 downto 0);
mux_in_1 : in STD_LOGIC_VECTOR (29 downto 0);
mux_in_2 : in STD_LOGIC_VECTOR (29 downto 0);
mux_in_3 : in STD_LOGIC_VECTOR (29 downto 0);
PCSrc : in STD_LOGIC_VECTOR (1 downto 0);
NextPC : out STD_LOGIC_VECTOR (29 downto 0));
end component;
component adder_30_bits
--completar!!
component and_next_adress
--completar!!
component se_next_address
--completar!!
component branch_condition_checker
--completar!!
signal sig0:std_logic; --Conexion de AND y Branch_condition_Checker
signal sig1:std_logic_vector(29 downto 0);--Une mux y salida de sumador
signal sig2:std_logic_vector(29 downto 0);--La seal va a ser igual a la
concatenacion de los 4 bits mas significativos de PC_31_2 con jta
signal sig3:std_logic_vector(29 downto 0);--Union de sumador(entrada x) con
componente AND
signal sig4:std_logic_vector(29 downto 0);--Union de componente AND y
componente SE

begin

47

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

mux_4_30_bits_1 :mux_4_30_bits
Port Map (
--completar!!
);
adder_30_bits_1:adder_30_bits
Port Map (
--completar!!
);
and_next_address_1:and_next_adress
Port Map (
--completar!!
);
se_next_address_1:se_next_address
Port Map (
--completar!!
);
branch_condition_checker_1:branch_condition_checker
Port Map (
--completar!!
);
na_IncrPC<=sig1(29 downto 2)&"00";
--na_IncrPC los dos bits menos
significativos siempre son 0;
sig2<=sig1(29 downto 26)&na_jta;-- en las diapositivas aparece tachado los 4
bits na_PC_31_2 y se usan los 4 bits mas significativos de la primera entrada
del mux
end Behavioral;

5.

Bancodeprueba:
----------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY next_address_tb IS
END next_address_tb;
ARCHITECTURE behavior OF next_address_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT next_address
PORT(
na_rt : IN std_logic_vector(31 downto 0);
na_rs : IN std_logic_vector(31 downto 0);
na_PC_31_2 : IN std_logic_vector(29 downto 0);
na_jta : IN std_logic_vector(25 downto 0);
na_syscalladdr : IN std_logic_vector(29 downto 0);

48

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

na_BrType : IN std_logic_vector(1 downto 0);


na_PCSrc : IN std_logic_vector(1 downto 0);
na_NextPC : OUT std_logic_vector(29 downto 0);
na_IncrPC : OUT std_logic_vector(29 downto 0)
);
END COMPONENT;

--Inputs
signal na_rt : std_logic_vector(31 downto 0) := (others => '0');
signal na_rs : std_logic_vector(31 downto 0) := (others => '0');
signal na_PC_31_2 : std_logic_vector(29 downto 0) := (others => '0');
signal na_jta : std_logic_vector(25 downto 0) := (others => '0');
signal na_syscalladdr : std_logic_vector(29 downto 0) := (others => '0');
signal na_BrType : std_logic_vector(1 downto 0) := (others => '0');
signal na_PCSrc : std_logic_vector(1 downto 0) := (others => '0');
--Outputs
signal na_NextPC : std_logic_vector(29 downto 0);
signal na_IncrPC : std_logic_vector(29 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: next_address PORT MAP (
na_rt => na_rt,
na_rs => na_rs,
na_PC_31_2 => na_PC_31_2,
na_jta => na_jta,
na_syscalladdr => na_syscalladdr,
na_BrType => na_BrType,
na_PCSrc => na_PCSrc,
na_NextPC => na_NextPC,
na_IncrPC => na_IncrPC
);
Next_address_test:Process
begin
--PC_31_2(PC actual) + 1
--Para instrucciones tipo R, operaciones logicas, carga y almacenaje en
memoria
na_rt<="00000000000000000000000000000001";--32 bits// un valor cualquiera
na_rs<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_PC_31_2<="000000000000000000000000000000";--30 bits // Asumimos que el PC
empezo en 0
na_jta<="00000000000000000000000011";--26 bits // jump target address
na_syscalladdr<="000000000000000000000000000100";--30 bits
na_BrType<="00";
na_PCSrc<="00";
wait for 10 ns;
--PC_31_2(PC actual) + 1 +imm(que viene del jta luego de pasar por el SE y
ser extendido en signo)
--Esto funciona para cualquier instruccion de bifurcacion

49

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

na_rt<="00000000000000000000000000000010";--32 bits// un valor cualquiera


na_rs<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_PC_31_2<="000000000000000000000000000000";--30 bits // Asumimos que el PC
empezo en 0
na_jta<="00000000000000000000000011";--26 bits // jump target address
na_syscalladdr<="000000000000000000000000000100";--30 bits
na_BrType<="01";--bifurcar si son iguales
na_PCSrc<="00";--valor necesario para bifurcar
wait for 10 ns;
--PC_31_2(PC actual/ 4 bits mas significativos) &(concatenado) jta (26 bits)
--Para instrucciones j o jal
na_rt<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_rs<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_PC_31_2<="101000000000000000000000000000";--30 bits // Asumimos que el PC
empezo en 0
na_jta<="00000000000000000000000011";--26 bits // jump target address
na_syscalladdr<="000000000000000000000000000100";--30 bits
na_BrType<="00";--no interesa el valor
na_PCSrc<="01";--salto
wait for 10 ns;
--Toma los 30 bits mas significativos de rs (32 bits)
--Para instruccion jr (Salto registro)
na_rt<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_rs<="10101010101010101010101010101010";--32 bits// un valor cualquiera
na_PC_31_2<="101000000000000000000000000000";--30 bits // Asumimos que el PC
empezo en 0
na_jta<="00000000000000000000000011";--26 bits // jump target address
na_syscalladdr<="000000000000000000000000000100";--30 bits
na_BrType<="00";--no interesa el valor
na_PCSrc<="10";--salta registro
wait for 10 ns;
--Muestra a la salida el valor de syscalladdr
--Instruccion syscall para pedir uso del sistema
na_rt<="00000000000000000000000000000010";--32 bits// un valor cualquiera
na_rs<="10101010101010101010101010101010";--32 bits// un valor cualquiera
na_PC_31_2<="101000000000000000000000000000";--30 bits // Asumimos que el PC
empezo en 0
na_jta<="00000000000000000000000011";--26 bits // jump target address
na_syscalladdr<="000000000000000000000000000100";--30 bits
na_BrType<="00";--no interesa el valor
na_PCSrc<="11";--Peticion del sistema syscall
wait for 10 ns;
end process;
END;

6.

Simulacin:

50

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Fig.26SimulaciondelbloqueNEXTADDRES

51

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Sntesis y simulacin de la ruta de datos.


Introduccin
La Fig. 25 muestra la ruta de datos completa del procesador que estamos implementando. En esta etapa es
necesario colocar todos los componentes que hemos presentado, analizado e implementado antes para formar
un diagrama esquemtico como el que se presenta en la Fig. 25. Para ello crearemos el componente
datapath y aplicaremos un banco de prueba para comprobar su correcto funcionamiento.

Fig.27Rutadedatosdeciclosencilla

1. CdigodelcomponenteenVHDL:
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity datapath is
Port ( clk_RegFile : in STD_LOGIC;
clk_PC : in STD_LOGIC;
PCSrc : in STD_LOGIC_VECTOR (1 downto 0);
BrType : in STD_LOGIC_VECTOR (1 downto 0);
RegDst : in STD_LOGIC_VECTOR (1 downto 0);
RegWrite : in STD_LOGIC;

52

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ALUSrc : in STD_LOGIC;
add_sub : in STD_LOGIC;
logic_function : in STD_LOGIC_VECTOR (1 downto 0);
function_class : in STD_LOGIC_VECTOR (1 downto 0);
--constant_amount : in STD_LOGIC_VECTOR (4 downto 0);
constant_var : in STD_LOGIC;
shift_function : in STD_LOGIC_VECTOR (1 downto 0);
DataRead : in STD_LOGIC;
DataWrite : in STD_LOGIC;
RegInSrc : in STD_LOGIC_VECTOR (1 downto 0);
op : out STD_LOGIC_VECTOR (5 downto 0);
fn : out STD_LOGIC_VECTOR (5 downto 0);
--verificando salida de la alu
test_alu_out:out STD_LOGIC_VECTOR(31 downto 0);
test_constant_amount:out STD_LOGIC_VECTOR (4 downto 0);
test_y_alu:out STD_LOGIC_VECTOR(31 downto 0);
test_rs:out STD_LOGIC_VECTOR(31 downto 0);
test_rt:out STD_LOGIC_VECTOR(31 downto 0);
test_im:out STD_LOGIC_VECTOR(31 downto 0);
--test de PC
test_Pc_in:out STD_LOGIC_VECTOR(29 downto 0);
test_Pc_out:out STD_LOGIC_VECTOR(29 downto 0);
test_instruc_out: out STD_LOGIC_VECTOR(31 downto 0);

--Muestreando el registro para ver los


REG_T0: out STD_LOGIC_VECTOR(31 downto
REG_T1: out STD_LOGIC_VECTOR(31 downto
REG_T3: out STD_LOGIC_VECTOR(31 downto
REG_T4: out STD_LOGIC_VECTOR(31 downto
corrimiento a la izquierda
REG_T5: out STD_LOGIC_VECTOR(31 downto
a la derecha

valores de fibonacci
0);
0);
0);
0);--aqui vere el
0)--aqui vere el corrimiento

);
end datapath;
architecture Behavioral of datapath is
component next_address
Port (
na_rt : in STD_LOGIC_VECTOR (31 downto 0);
na_rs : in STD_LOGIC_VECTOR (31 downto 0);
na_PC_31_2 : in STD_LOGIC_VECTOR (29 downto 0);
na_jta : in STD_LOGIC_VECTOR (25 downto 0);
na_syscalladdr : in STD_LOGIC_VECTOR (29 downto 0);
na_BrType : in STD_LOGIC_VECTOR (1 downto 0);
na_PCSrc : in STD_LOGIC_VECTOR (1 downto 0);
na_NextPC : out STD_LOGIC_VECTOR (29 downto 0);
na_IncrPC: out STD_LOGIC_VECTOR (29 downto 0));
end component;
component Pc
Port (
pc_in : in

53

STD_LOGIC_VECTOR (29 downto 0);

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

pc_out : out
end component;

clk : in STD_LOGIC;
STD_LOGIC_VECTOR (29 downto 0));

component instr_cache
Port (
instr_cache_addr : in
instr_cache_out : out
end component;

STD_LOGIC_VECTOR (3 downto 0);


STD_LOGIC_VECTOR (31 downto 0));

component mux_datapath_regfile
Port ( mux_in_0 : in STD_LOGIC_VECTOR (4 downto 0);
mux_in_1 : in STD_LOGIC_VECTOR (4 downto 0);
mux_in_2 : in STD_LOGIC_VECTOR (4 downto 0);
RegDst : in STD_LOGIC_VECTOR (1 downto 0);
mux_out : out STD_LOGIC_VECTOR (4 downto 0));
end component;
component reg_file_32_bits
port (
write_enable: in STD_LOGIC;--Activar la escritura del registro
clk: in STD_LOGIC;--Clock
--read_enable: in STD_LOGIC;--Activar la lectura del registro
read_addr_1: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 1
read_addr_2: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 2
write_addr: in STD_LOGIC_VECTOR(4 downto 0);--direccion de escritura
data_in: in STD_LOGIC_VECTOR(31 downto 0);--Dato de entrada
data_out_1: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la
direccion 1
data_out_2: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la
direccion 2
REG_T0:
REG_T1:
REG_T3:
REG_T4:

out
out
out
out

STD_LOGIC_VECTOR(31 downto 0);


STD_LOGIC_VECTOR(31 downto 0);
STD_LOGIC_VECTOR(31 downto 0);
STD_LOGIC_VECTOR(31 downto 0);--aqui vere el corrimiento a la izquierda
REG_T5: out STD_LOGIC_VECTOR(31 downto 0)--aqui vere el corrimiento

a la derecha
);
end component;
component se_main
Port (
se_in : in STD_LOGIC_VECTOR (15 downto 0);
se_out : out STD_LOGIC_VECTOR (31 downto 0));
end component;
component mux_datapath_alu
Port (
mux_rt_in : in STD_LOGIC_VECTOR (31 downto 0);
mux_se_in : in STD_LOGIC_VECTOR (31 downto 0);
ALUSrc:in STD_LOGIC;
mux_out : out STD_LOGIC_VECTOR (31 downto 0));
end component;
component alu
Port ( x : in

54

STD_LOGIC_VECTOR (31 downto 0);

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

y : in STD_LOGIC_VECTOR (31 downto 0);


constant_amount : in STD_LOGIC_VECTOR (4 downto 0);
constant_var : in STD_LOGIC;
function_class : in STD_LOGIC_VECTOR (1 downto 0);
logic_function : in STD_LOGIC_VECTOR (1 downto 0);
add_sub : in STD_LOGIC;
shift_function : in STD_LOGIC_VECTOR (1 downto 0);
s : out STD_LOGIC_VECTOR (31 downto 0));
end component;
component data_cache
Port (
data_cache_address : in STD_LOGIC_VECTOR (3 downto 0);
data_in : in STD_LOGIC_VECTOR (31 downto 0);
data_read : in STD_LOGIC;
data_write : in STD_LOGIC;
data_out : out STD_LOGIC_VECTOR (31 downto 0));
end component;
component mux_datapath_datacache
Port (
mux_datacache_in : in STD_LOGIC_VECTOR (31 downto 0);
mux_alu_in : in STD_LOGIC_VECTOR (31 downto 0);
mux_incrPC_in : in STD_LOGIC_VECTOR (31 downto 0);
RegIncr : in STD_LOGIC_VECTOR (1 downto 0);
mux_out : out STD_LOGIC_VECTOR (31 downto 0));
end component;
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
begin

sig0:STD_LOGIC_VECTOR (31 downto 0);


sig1:STD_LOGIC_VECTOR (31 downto 0);
sig2:STD_LOGIC_VECTOR (29 downto 0);
sig3:STD_LOGIC_VECTOR (31 downto 0);
sig4:STD_LOGIC_VECTOR (29 downto 0);
sig5:STD_LOGIC_VECTOR (29 downto 0);
sig6:STD_LOGIC_VECTOR (4 downto 0);
sig7:STD_LOGIC_VECTOR (31 downto 0);
sig8:STD_LOGIC_VECTOR (31 downto 0);
sig9:STD_LOGIC_VECTOR (31 downto 0);
sig10:STD_LOGIC_VECTOR (31 downto 0);
sig11:STD_LOGIC_VECTOR (31 downto 0);
sig12:STD_LOGIC_VECTOR (31 downto 0);

next_address_1:next_address
PORT MAP (
na_rt =>sig0,
na_rs =>sig1,
na_PC_31_2 =>sig2,
na_jta =>sig3(25 downto 0),
na_syscalladdr =>"000000000000000000000000000000",
na_BrType =>BrType,
na_PCSrc =>PCSrc,
na_NextPC =>sig4,
na_IncrPC =>sig5
);
Pc_1:Pc
PORT MAP (
pc_in =>sig4,

55

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

clk =>clk_PC,
pc_out =>sig2
);
instr_cache_1:instr_cache
PORT MAP (
instr_cache_addr =>sig2(3 downto 0),
instr_cache_out =>sig3
);
mux_datapath_regfile_1:mux_datapath_regfile
PORT MAP (
mux_in_0 =>sig3(20 downto 16),--????
mux_in_1 =>sig3(15 downto 11),--???
mux_in_2 =>"11111",--?????
RegDst =>RegDst,
mux_out =>sig6
);
reg_file_32_bits_1:reg_file_32_bits
PORT MAP (
write_enable =>RegWrite,
clk =>clk_RegFile,
--read_enable =>'1',
read_addr_1 =>sig3(25 downto 21),
read_addr_2 =>sig3(20 downto 16),
write_addr =>sig6,
data_in =>sig7,
data_out_1 =>sig1,
data_out_2 =>sig0,
REG_T0=>REG_T0,
REG_T1=>REG_T1,
REG_T3=>REG_T3,
REG_T4=>REG_T4,
REG_T5=>REG_T5

);
se_main_1:se_main
PORT MAP (
se_in =>sig3(15 downto 0),
se_out =>sig8
);
mux_datapath_alu_1:mux_datapath_alu
PORT MAP (
mux_rt_in =>sig0,
mux_se_in =>sig8,
ALUSrc =>ALUSrc,
mux_out =>sig9
);
alu_1:alu
PORT MAP(

56

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

x =>sig1,
y =>sig9,
constant_amount =>sig3(10 downto 6),
constant_var =>constant_var,
function_class =>function_class,
logic_function =>logic_function,
add_sub =>add_sub,
shift_function =>shift_function,
s =>sig10
);
data_cache_1:data_cache
PORT MAP (
data_cache_address =>sig10(3 downto 0),
data_in =>sig0,
data_read =>DataRead,
data_write =>DataWrite,
data_out =>sig11
);
mux_datapath_datacache_1:mux_datapath_datacache
PORT MAP (
mux_datacache_in =>sig11,
mux_alu_in =>sig10,
mux_incrPC_in =>sig12,
RegIncr =>RegInSrc,
mux_out =>sig7
);
sig12<=sig5&"00";
op<=sig3(31 downto 26);
fn<=sig3(5 downto 0);
test_alu_out<=sig10;
test_constant_amount<=sig3(10 downto 6);
test_y_alu<=sig9;
test_rs<=sig1;
test_rt<=sig0;
test_im<=sig8;
test_Pc_in<=sig4;
test_Pc_out<=sig2;
test_instruc_out<=sig3;
end Behavioral;

2. Bancodeprueba:
-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY datapath_tb IS
END datapath_tb;

57

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ARCHITECTURE behavior OF datapath_tb IS


-- Component Declaration for the Unit Under Test (UUT)
COMPONENT datapath
PORT(
clk_RegFile : IN std_logic;
clk_PC : IN std_logic;
PCSrc : IN std_logic_vector(1 downto 0);
BrType : IN std_logic_vector(1 downto 0);
RegDst : IN std_logic_vector(1 downto 0);
RegWrite : IN std_logic;
ALUSrc : IN std_logic;
add_sub : IN std_logic;
logic_function : IN std_logic_vector(1 downto 0);
function_class : IN std_logic_vector(1 downto 0);
constant_var : IN std_logic;
shift_function : IN std_logic_vector(1 downto 0);
DataRead : IN std_logic;
DataWrite : IN std_logic;
RegInSrc : IN std_logic_vector(1 downto 0);
op : OUT std_logic_vector(5 downto 0);
fn : OUT std_logic_vector(5 downto 0);
test_alu_out : OUT std_logic_vector(31 downto 0);
test_constant_amount : OUT std_logic_vector(4 downto 0);
test_y_alu : OUT std_logic_vector(31 downto 0);
test_rs : OUT std_logic_vector(31 downto 0);
test_rt : OUT std_logic_vector(31 downto 0);
test_im : OUT std_logic_vector(31 downto 0);
REG_T0 : OUT std_logic_vector(31 downto 0);
REG_T1 : OUT std_logic_vector(31 downto 0);
REG_T3 : OUT std_logic_vector(31 downto 0)
);
END COMPONENT;

--Inputs
signal clk_RegFile : std_logic := '0';
signal clk_PC : std_logic := '0';
signal PCSrc : std_logic_vector(1 downto 0) := (others => '0');
signal BrType : std_logic_vector(1 downto 0) := (others => '0');
signal RegDst : std_logic_vector(1 downto 0) := (others => '0');
signal RegWrite : std_logic := '0';
signal ALUSrc : std_logic := '0';
signal add_sub : std_logic := '0';
signal logic_function : std_logic_vector(1 downto 0) := (others => '0');
signal function_class : std_logic_vector(1 downto 0) := (others => '0');
signal constant_var : std_logic := '0';
signal shift_function : std_logic_vector(1 downto 0) := (others => '0');
signal DataRead : std_logic := '0';
signal DataWrite : std_logic := '0';
signal RegInSrc : std_logic_vector(1 downto 0) := (others => '0');
--Outputs
signal op : std_logic_vector(5 downto 0);
signal fn : std_logic_vector(5 downto 0);

58

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

signal
signal
signal
signal
signal
signal
signal
signal
signal

test_alu_out : std_logic_vector(31 downto 0);


test_constant_amount : std_logic_vector(4 downto 0);
test_y_alu : std_logic_vector(31 downto 0);
test_rs : std_logic_vector(31 downto 0);
test_rt : std_logic_vector(31 downto 0);
test_im : std_logic_vector(31 downto 0);
REG_T0 : std_logic_vector(31 downto 0);
REG_T1 : std_logic_vector(31 downto 0);
REG_T3 : std_logic_vector(31 downto 0);

-- Clock period definitions


constant clk_RegFile_period : time := 1us;
constant clk_PC_period : time := 1us;
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: datapath PORT MAP (
clk_RegFile => clk_RegFile,
clk_PC => clk_PC,
PCSrc => PCSrc,
BrType => BrType,
RegDst => RegDst,
RegWrite => RegWrite,
ALUSrc => ALUSrc,
add_sub => add_sub,
logic_function => logic_function,
function_class => function_class,
constant_var => constant_var,
shift_function => shift_function,
DataRead => DataRead,
DataWrite => DataWrite,
RegInSrc => RegInSrc,
op => op,
fn => fn,
test_alu_out => test_alu_out,
test_constant_amount => test_constant_amount,
test_y_alu => test_y_alu,
test_rs => test_rs,
test_rt => test_rt,
test_im => test_im,
REG_T0 => REG_T0,
REG_T1 => REG_T1,
REG_T3 => REG_T3
);

Datapath_test:Process
begin
--clk_RegFile <= '1';
--clk_PC <= '1';
--PCSrc <= "00";
--BrType <= "00";
--RegDst <= "00";
--RegWrite <= '1';
--ALUSrc <= '1';
--add_sub <= '0';

59

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--logic_function <= "00";


--function_class <= "10";
--constant_var <= '1';
--shift_function <= "00";
--DataRead <= '0';
--DataWrite <= '0';
--RegInSrc <= "01";
--wait for 10 ns;
clk_RegFile <= '1';
clk_PC <= '0';
PCSrc <= "00";
BrType <= "00";
RegDst <= "01";
RegWrite <= '1';
ALUSrc <= '0';
add_sub <= '0';
logic_function <= "00";
function_class <= "00";
constant_var <= '0';
shift_function <= "01";
DataRead <= '0';
DataWrite <= '0';
RegInSrc <= "01";
wait for 10 ns;
--dato en el registro 00000000000000000000000000001000
--Instruccion
000000 00000 00001 00010 00100 000000
end Process;

END;

60

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

3. Simulacin

Fig.28Simulacindelarutadedatossencilla

61

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Derivacin de las seales de control.


Las instrucciones que se emplean es este procesador requieren de un conjunto de seales de control. La Fig.
27 muestra el cdigo de operacin y/o el cdigo de operacin extendido que permite identificar cada
instruccin.

Fig.29Cdigosdeoperacindelasinstrucciones
Para cada instruccin existe un grupo de seales de control que deben ser generadas a partir de la
identificacin de dicha instruccin.

Implementacin y simulacin en VHDL de


la unidad de control. Bloques:
decodificadores, circuitos combinacionales.
En cada una de las etapas de la ruta de datos hay algunas seales de control que se encargan de regular cada
una de las etapas. La unidad de control tomo como nicas entradas los valores op y fn enviados por la
ruta de datos para enviar hacia la ruta de datos las respectivas seales de control. En el presente proyecto se ha
implementado 11 seales de control distribuidas a lo largo de la ruta de datos, y son las siguientes:

62

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Fig.30Sealesdecontroldelarutadedatos
Donde:

RegWrite: Es la seal que habilita la escritura en el archivo de registros de un dato que ser
almacenado en la direccin de cinco bits presente en la entrada de la direccin de escritura del
archivo de registros.

RegDst1 y RegDst2: Seales conectadas al canal de seleccin del multiplexor ubicado a la entrada de
la direccin de escritura del archivo de registros. Si su valor es 00 la direccin de escritura ser el
valor de rt, para un valor 01 la direccin corresponde al campo rd y para un valor de 10 corresponde
a la direccin del registro 31.

RegInSrc1 y RegInSrc2: Seales de control conectadas al multiplexor de la ltima etapa de la ruta de


datos. Si toma el valor 00 dar paso al dato proveniente del cache de datos. Si toma el valor 01 la
salida ser igual al resultado de la operacin realizada dentro de la ALU y para un valor de 10 dejar
pasar el valor proveniente del archivo de registros.

AluSrc: Seal que controla el canal de seleccin del multiplexor conectado a la parte inferior de la
entrada de la ALU. Si su valor es 0 se dejar pasar el valor rt caso contrario el valor que presentar a
su salida ser el valor imm extendido en signo.

AddSub: Esta seal es la que controla la operacin de adicin y subtraccin. Cuando toma el valor
de 0 ser ejecutada una suma entre los dos valores presentes a la entrada del bloque sumador de 32
bits, caso contrario se ejecutar las resta haciendo uso del completo a dos.

LogicFn0 y LogicFn1: Estas seales de control de dos bits son encargadas de controlar la operacin a
realizarse en la unidad aritmtica lgica de la ALU. Si su valor es 00 corresponde a una operacin
AND, si su valor es 01 es una operacin OR, para un valor 10 es una operacin XOR y para un valor
11 determinar una operacin NOR.

63

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

DataWrite: Cuando esta seal esta activa habilita la escritura en el cache de datos.

DataRead: Cuando esta seal esta activa habilita la lectura en el cache de datos.

BrType0 y BrType1: Seal de control conectada a la sub-unidad BRANCH CONDITION CHECKER


del componente NEXT ADDRESS de la ruta de datos. Esta seal es postulada cuando hay que
realizar la verificacin de la condicin de una instruccin de bifurcacin.

PCSrc0 y PCSrc1: Mediante este conjunto de seales se realiza el control del multiplexor presente en
el interior del bloque NEXT ADDRESS. Para un valor de 00 de esta seal se da paso al valor del
PC+1, en caso tenga un valor de 01 se da paso al valor de jta concatenando con los cuatro bits ms
significativos tomados de la salida donde esta PC+1. Para un valor de 10 se presenta el contenido del
registro rd. En caso de que sea 11 el valor ser igual al valor del vector de inerrupcin. Para este
procesador no se ha implementado manejo de interrupciones.

ConstantVar: Esta seal va unidad al canal de seleccin del multiplexor que controla la unidad de
corrimiento que hace el desplazamiento de los bits. Es as que si asume un valor de cero
corresponder un corrimiento constantes (esto es que depender del valor literal que venga
expresador en la instruccin). Caso contrario si tiene un valor de uno se deja pasar a la salida del
multiplexor la cantidad de corrimiento variable (esto es depender del contenido de un registro).

En el diseo de la unidad de control implementad a en VHDL se realiz haciendo uso de los dos
decodificadores que se muestran a continuacin:

Fig.31Identificacindelasinstrucciones

64

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

DecodificadordeInstrucciones1
1.

Definicin:
El objetivo de este componente es identificar las instrucciones que quedan definidas solo por el
cdigo de operacin (OPCODE). Las instrucciones de este tipo no requieren del cdigo de operacin
extendido.

2.

Implementacin:
Ser realizada siguiendo la Fig. 31.

3. InstruccionesausarenVHDL:
No aplica

4. CdigodelcomponenteenVHDL:
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity deco_1_control_unit is
Port ( deco_1_enable_in : in STD_LOGIC;
deco_1_op_in : in STD_LOGIC_VECTOR (5 downto 0);
deco_1_out : out STD_LOGIC_VECTOR (63 downto 0));
end deco_1_control_unit;
architecture Behavioral of deco_1_control_unit is
begin
Process(deco_1_enable_in, deco_1_op_in)
begin
if(deco_1_enable_in='1') Then
case deco_1_op_in is
when "000000" => --OP="0" corresponde a las instruccciones Rtype
deco_1_out<="0000000000000000000000000000000000000000000000000000000000000001";
when "000001" => --OP="1" corresponde a la instruccion: Branch on less than
zero
deco_1_out<="0000000000000000000000000000000000000000000000000000000000000010";
when "000010" => --OP="2" corresponde a la instruccion: Jump

65

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

deco_1_out<="0000000000000000000000000000000000000000000000000000000000000100";
when "000011" => --OP="3" corresponde a la instruccion: Jump and Link
deco_1_out<="0000000000000000000000000000000000000000000000000000000000001000";
when "000100" => --OP="4" corresponde a la instruccion: Branch on equal
deco_1_out<="0000000000000000000000000000000000000000000000000000000000010000";
when "000101" => --OP="5" corresponde a la instruccion: Branch on not equal
deco_1_out<="0000000000000000000000000000000000000000000000000000000000100000";
when "001000" => --OP="8" corresponde a la instruccion: Add inmediate
deco_1_out<="0000000000000000000000000000000000000000000000000000000100000000";
when "001010" => --OP="10" corresponde a la instruccion: Set less than
immediate
deco_1_out<="0000000000000000000000000000000000000000000000000000010000000000";
when "001100" => --OP="12" corresponde a la instruccion: AND immediate
deco_1_out<="0000000000000000000000000000000000000000000000000001000000000000";
when "001101" => --OP="13" corresponde a la instruccion: OR immediate
deco_1_out<="0000000000000000000000000000000000000000000000000010000000000000";
when "001110" => --OP="14" corresponde a la instruccion: XOR immediate
deco_1_out<="0000000000000000000000000000000000000000000000000100000000000000";
when "001111" => --OP="15" corresponde a la instruccion: Load Upper immediate
// Segun libro OP=001111, le pondre OP=16 para implementar LUI con el corrimiento
deco_1_out<="0000000000000000000000000000000000000000000000001000000000000000";
when "100011" => --OP="35" corresponde a la instruccion: Load Word
deco_1_out<="0000000000000000000000000000100000000000000000000000000000000000";
when "101011" => --OP="43" corresponde a la instruccion: Store Word
deco_1_out<="0000000000000000000010000000000000000000000000000000000000000000";
when others => --Para el caso de otras instrucciones
deco_1_out<="0000000000000000000000000000000000000000000000000000000000000000";
end case;
else -- si el enable esta desactivado
deco_1_out<="0000000000000000000000000000000000000000000000000000000000000000";
end if;
end Process;
end Behavioral;

5. Bancodeprueba:
--------------------------------------------------------------------------------

66

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY deco_1_control_unit_tb IS
END deco_1_control_unit_tb;
ARCHITECTURE behavior OF deco_1_control_unit_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT deco_1_control_unit
PORT(
deco_1_enable_in : IN std_logic;
deco_1_op_in : IN std_logic_vector(5 downto 0);
deco_1_out : OUT std_logic_vector(63 downto 0)
);
END COMPONENT;

--Inputs
signal deco_1_enable_in : std_logic := '0';
signal deco_1_op_in : std_logic_vector(5 downto 0) := (others => '0');
--Outputs
signal deco_1_out : std_logic_vector(63 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: deco_1_control_unit PORT MAP (
deco_1_enable_in => deco_1_enable_in,
deco_1_op_in => deco_1_op_in,
deco_1_out => deco_1_out
);
Deco_1_Control_Unit_test:Process
begin
deco_1_enable_in<='0';--enable desactivado
deco_1_op_in<="000000";
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="000000";--op=0
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="000001";--op=1
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="000010";--op=2
wait for 10 ns;

67

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

deco_1_enable_in<='1';
deco_1_op_in<="000011";--op=3
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="000100";--op=4
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="000101";--op=5
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="001000";--op=8
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="001010";--op=10
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="001100";--op=12
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="001101";--op=13
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="001110";--op=14
wait for 10 ns;
deco_1_enable_in<='1';
deco_1_op_in<="100011";--op=35
wait for 10 ns;

deco_1_enable_in<='1';
deco_1_op_in<="101011";--op=43
wait for 10 ns;
end Process;
END;

6. Simulacin

Fig.32SimulacindeIdecodificadordeinstrucciones1

68

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

DecodificadordeInstrucciones2
1. Definicin:
El objetivo de este componente es identificar las instrucciones que quedan definidas por el cdigo de
operacin extendida cuando el OPCODE es igual a cero.

2. Implementacin:
Ser realizada siguiendo la Fig. 31.

3. InstruccionesausarenVHDL:
No aplica

4. CdigodelcomponenteenVHDL:
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity deco_2_control_unit is
Port ( deco_2_enable_in : in STD_LOGIC;
deco_2_fn_in : in STD_LOGIC_VECTOR (5 downto 0);
deco_2_out : out STD_LOGIC_VECTOR (63 downto 0));
end deco_2_control_unit;
architecture Behavioral of deco_2_control_unit is
begin
Process(deco_2_enable_in, deco_2_fn_in)
begin
if(deco_2_enable_in='1') Then
case deco_2_fn_in is --FN="0" corresponde a la instrucccion: shift left logical
when "000000" =>
deco_2_out<="0000000000000000000000000000000000000000000000000000000000000001";
when "000010" => --FN="2" corresponde a la instrucccion: Shift right logical
deco_2_out<="0000000000000000000000000000000000000000000000000000000000000100";
when "000011" => --FN="3" corresponde a la instrucccion: Shift right
arithmetic
deco_2_out<="0000000000000000000000000000000000000000000000000000000000001000";
when "000100" => --FN="4" corresponde a la instrucccion: Shift left logical
variable // No implementado en Shifter ALU

69

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

deco_2_out<="0000000000000000000000000000000000000000000000000000000000010000";
when "000110" => --FN="6" corresponde a la instrucccion: Shift right logical
variable //No implementado en Shifter ALU
deco_2_out<="0000000000000000000000000000000000000000000000000000000001000000";
when "000111" => --FN="7" corresponde a la instrucccion: Shift right arith
variable // No implementado en Shifter ALU
deco_2_out<="0000000000000000000000000000000000000000000000000000000010000000";
when "001000" => --FN="8" corresponde a la instrucccion: Jump register
deco_2_out<="0000000000000000000000000000000000000000000000000000000100000000";
when "001100" => --FN="12" corresponde a la instrucccion: System call
deco_2_out<="0000000000000000000000000000000000000000000000000001000000000000";
when "100000" => --FN="32" corresponde a la instrucccion: Add
deco_2_out<="0000000000000000000000000000000100000000000000000000000000000000";
when "100010" => --FN="34" corresponde a la instrucccion: Substract
deco_2_out<="0000000000000000000000000000010000000000000000000000000000000000";
when "100100" => --FN="36" corresponde a la instrucccion: AND
deco_2_out<="0000000000000000000000000001000000000000000000000000000000000000";
when "100101" => --FN="37" corresponde a la instrucccion: OR
deco_2_out<="0000000000000000000000000010000000000000000000000000000000000000";
when "100110" => --FN="38" corresponde a la instrucccion: XOR
deco_2_out<="0000000000000000000000000100000000000000000000000000000000000000";
when "100111" => --FN="39" corresponde a la instrucccion: NOR
deco_2_out<="0000000000000000000000001000000000000000000000000000000000000000";
when "101010" => --FN="42" corresponde a la instrucccion: Set less than
deco_2_out<="0000000000000000000001000000000000000000000000000000000000000000";
when others => -- Para los demas valores para otras instrucciones
deco_2_out<="0000000000000000000000000000000000000000000000000000000000000000";
end case;
else -- en caso que enable este desactivado
deco_2_out<="0000000000000000000000000000000000000000000000000000000000000000";
end if;
end Process;
end Behavioral;

5. Bancodepruebas
-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;

70

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ENTITY deco_2_control_unit_tb IS
END deco_2_control_unit_tb;
ARCHITECTURE behavior OF deco_2_control_unit_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT deco_2_control_unit
PORT(
deco_2_enable_in : IN std_logic;
deco_2_fn_in : IN std_logic_vector(5 downto 0);
deco_2_out : OUT std_logic_vector(63 downto 0)
);
END COMPONENT;
--Inputs
signal deco_2_enable_in : std_logic := '0';
signal deco_2_fn_in : std_logic_vector(5 downto 0) := (others => '0');
--Outputs
signal deco_2_out : std_logic_vector(63 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: deco_2_control_unit PORT MAP (
deco_2_enable_in => deco_2_enable_in,
deco_2_fn_in => deco_2_fn_in,
deco_2_out => deco_2_out
);
Deco_1_Control_Unit_test:Process
begin
deco_2_enable_in<='0';--enable desactivado
deco_2_fn_in<="000000";
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="000000";--op=0
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="000010";--op=2
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="000011";--op=3
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="000100";--op=4
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="000110";--op=6
wait for 10 ns;

71

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

deco_2_enable_in<='1';
deco_2_fn_in<="000111";--op=7
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="001000";--op=8
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="001100";--op=12
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100000";--op=32
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100010";--op=34
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100100";--op=36
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100101";--op=37
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100110";--op=38
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="100111";--op=39
wait for 10 ns;
deco_2_enable_in<='1';
deco_2_fn_in<="101010";--op=42
wait for 10 ns;
end Process;
END;

6. Simulacin

Fig.33SimulacindeIdecodificadordeinstrucciones2

72

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

UnidadAuxiliardelaUniaddeControl

1. Definicion:
La unidad de control auxiliary implementa las ecuaciones lgicas que deben activarse una vez que se han
identificado las instrucciones en base a los decodificadores. Dado que este es un procesador de ciclo
sencillo solo se requiere de circuitos combinacionales para realizar el trabajo

2.CdigodelcomponenteenVHDL
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity aux_signals_control_unit is
Port ( data_decos_in : in STD_LOGIC_VECTOR (27 downto 0);
RegWrite : out STD_LOGIC;
RegDst : out STD_LOGIC_VECTOR (1 downto 0);
RegInSrc : out STD_LOGIC_VECTOR (1 downto 0);
ALUSrc : out STD_LOGIC;
Add_sub : out STD_LOGIC;
LogicFn : out STD_LOGIC_VECTOR (1 downto 0);
FnClass : out STD_LOGIC_VECTOR (1 downto 0);
DataRead : out STD_LOGIC;
DataWrite : out STD_LOGIC;
BrType : out STD_LOGIC_VECTOR (1 downto 0);
PCSrc : out STD_LOGIC_VECTOR (1 downto 0);
ConstantVar : out STD_LOGIC;
ShiftFn : out STD_LOGIC_VECTOR (1 downto 0));
end aux_signals_control_unit;
architecture Behavioral of aux_signals_control_unit is
signal
signal
signal
signal

arithInst: std_logic;
logicInst: std_logic;
immInst: std_logic;
shiftInst: std_logic;

--Entradas de data_decos_in provenientes de deco_1_control_unit


--[0]
--[1]
--[2]
--[3]
--[4]
--[5]
--[6]
--[7]

deco_1_out(1) => Branch on less than zero


deco_1_out(2) => Jump
deco_1_out(3) => Jump and Link
deco_1_out(4) => Branch on equal
deco_1_out(5) => Branch on not equal
deco_1_out(8) => Add inmediate
deco_1_out(10) => Set less than immediate
deco_1_out(12) => AND immediate

73

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--[8] deco_1_out(13) => OR immediate


--[9] deco_1_out(14) => XOR immediate
--[10] deco_1_out(15) => Load Upper immediate
--[11] deco_1_out(35) => Load Word
--[12] deco_1_out(43) => Store Word
---------------------------------------------------------------------------------------------Entradas de data_decos_in provenientes de deco_2_control_unit
--[13]
--[14]
--[15]
--[16]
--[17]
--[18]
--[19]
--[20]
--[21]
--[22]
--[23]
--[24]
--[25]
--[26]
--[27]

deco_2_out(0) => shift left logical


deco_2_out(2) => Shift right logical
deco_2_out(3) => Shift right arithmetic
deco_2_out(4) => Shift left logical variable
deco_2_out(6) => Shift right logical variable
deco_2_out(7) => Shift right arith variable
deco_2_out(8) => Jump register
deco_2_out(12) => System call
deco_2_out(32) => Add
deco_2_out(34) => Substract
deco_2_out(36) => AND
deco_2_out(37) => OR
deco_2_out(38) => XOR
deco_2_out(39) => NOR
deco_2_out(42) => Set less than

begin

arithInst<= data_decos_in(21) or data_decos_in(22) or data_decos_in(27) or data_decos_in(5)


or data_decos_in(6);
logicInst<= data_decos_in(23) or data_decos_in(24) or data_decos_in(25) or data_decos_in(26)
or data_decos_in(7) or data_decos_in(8) or data_decos_in(9);
immInst<= data_decos_in(10) or data_decos_in(5) or data_decos_in(6) or data_decos_in(7) or
data_decos_in(8) or data_decos_in(9);
shiftInst<= data_decos_in(13) or data_decos_in(14) or data_decos_in(15) or data_decos_in(16)
or data_decos_in(17) or data_decos_in(18);
-- RegWrite: Permite la escrita en el archivo de registro
RegWrite<= data_decos_in(10) or arithInst or logicInst or data_decos_in(11) or
data_decos_in(2) or shiftInst;
-- RegDst: Selecciona el canal en el Mux a la entrada del archivo de registro // 00 -> rt //
01 -> rd // 10 -> $31 // 11-> no se usa
RegDst(0)<= data_decos_in(21) or data_decos_in(22) or data_decos_in(27) or data_decos_in(23)
or data_decos_in(24) or data_decos_in(25) or data_decos_in(26) or shiftInst;
RegDst(1)<= data_decos_in(2);
--RegInSrc: Linea seleccion mux al final ruta de datos // 00->salida de cache de datos //
01->salida de ALU // 10->Valor del PC incrementado que viene del next Address // 11-> no se
usa
RegInSrc(0)<= data_decos_in(10) or arithInst or logicInst or shiftInst;
RegInSrc(1)<= data_decos_in(2);
-- ALUSrc: Linea de seleccion mux entrada inferior de la ALU // 0-> rt // 1-> version
extendida de signo del imm
ALUSrc<= data_decos_in(10) or data_decos_in(5) or data_decos_in(6) or data_decos_in(7) or
data_decos_in(8) or data_decos_in(9) or data_decos_in(11) or data_decos_in(12);

74

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--Add_sub: Linea de control de la ALU // 0->Suma y no le acarrea un 1 de entrada a la ALU //


1-> Diferencia para lo cual hace complemento a 1 y acarrea 1 a la ALU
Add_sub<= data_decos_in(22) or data_decos_in(27) or data_decos_in(6);
---LogicFn: Linea de control de la unidad logica de la ALU // 00->AND // 01->OR // 10->XOR
// 11->NOR
LogicFn(0)<= data_decos_in(24) or data_decos_in(26) or data_decos_in(8);
LogicFn(1)<= data_decos_in(25) or data_decos_in(26) or data_decos_in(9);
---FnClass: Linea de seleccion del mux interno de la ALU // 00-> Shift // 01-> Set less //
10-> Aritmetica // 11-> Logica
FnClass(0)<= data_decos_in(27) or data_decos_in(6) or logicInst;
FnClass(1)<= data_decos_in(21) or data_decos_in(22) or data_decos_in(5) or logicInst or
data_decos_in(11) or data_decos_in(12) ;
--DataRead: Permite la lectura de la cache de datos
DataRead<=data_decos_in(11);
--DataWrite: Permite la escritura de la cache de datos
DataWrite<=data_decos_in(12);
---BrType: Linea del Branch condition checker del Next Address // 01->beq // 10->bne // 11>bltz
BrType(0)<= data_decos_in(0) or data_decos_in(3);
BrType(1)<= data_decos_in(0) or data_decos_in(4);
--PCSrc: Linea seleccion del mux del next address // 00-> Para todas las demas instrucciones
// 01-> Jump // 10-> Jump register // 11->Syscall
PCSrc(0)<= data_decos_in(1) or data_decos_in(2) or data_decos_in(20);
PCSrc(1)<= data_decos_in(19) or data_decos_in(20);
--ConstantVar: Linea de seleccion del mux en la ALU que cuya salida va al shifter //0>Constant amount // 1->Variable amount
ConstantVar<= data_decos_in(16) or data_decos_in(17) or data_decos_in(18);
--ShiftFn: Linea de control del shifter // 00->No Shift // 01->Logical Left // 10->Logical
right // 11-> Arith right
ShiftFn(0)<= data_decos_in(13) or data_decos_in(15) or data_decos_in(16) or
data_decos_in(18);
ShiftFn(1)<= data_decos_in(14) or data_decos_in(15) or data_decos_in(17) or
data_decos_in(18);
end Behavioral;

3. Bancodeprueba
-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY aux_signals_control_unit_tb IS
END aux_signals_control_unit_tb;

75

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

ARCHITECTURE behavior OF aux_signals_control_unit_tb IS


-- Component Declaration for the Unit Under Test (UUT)
COMPONENT aux_signals_control_unit
PORT(
data_decos_in : IN std_logic_vector(27 downto 0);
RegWrite : OUT std_logic;
RegDst : OUT std_logic_vector(1 downto 0);
RegInSrc : OUT std_logic_vector(1 downto 0);
ALUSrc : OUT std_logic;
Add_sub : OUT std_logic;
LogicFn : OUT std_logic_vector(1 downto 0);
FnClass : OUT std_logic_vector(1 downto 0);
DataRead : OUT std_logic;
DataWrite : OUT std_logic;
BrType : OUT std_logic_vector(1 downto 0);
PCSrc : OUT std_logic_vector(1 downto 0);
ConstantVar : OUT std_logic;
ShiftFn : OUT std_logic_vector(1 downto 0)
);
END COMPONENT;

--Inputs
signal data_decos_in : std_logic_vector(27 downto 0) := (others => '0');
--Outputs
signal RegWrite : std_logic;
signal RegDst : std_logic_vector(1 downto 0);
signal RegInSrc : std_logic_vector(1 downto 0);
signal ALUSrc : std_logic;
signal Add_sub : std_logic;
signal LogicFn : std_logic_vector(1 downto 0);
signal FnClass : std_logic_vector(1 downto 0);
signal DataRead : std_logic;
signal DataWrite : std_logic;
signal BrType : std_logic_vector(1 downto 0);
signal PCSrc : std_logic_vector(1 downto 0);
signal ConstantVar : std_logic;
signal ShiftFn : std_logic_vector(1 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: aux_signals_control_unit PORT MAP (
data_decos_in => data_decos_in,
RegWrite => RegWrite,
RegDst => RegDst,
RegInSrc => RegInSrc,
ALUSrc => ALUSrc,
Add_sub => Add_sub,
LogicFn => LogicFn,
FnClass => FnClass,
DataRead => DataRead,
DataWrite => DataWrite,
BrType => BrType,

76

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

PCSrc => PCSrc,


ConstantVar => ConstantVar,
ShiftFn => ShiftFn
);
--Entradas de data_decos_in provenientes de deco_1_control_unit
--[0] deco_1_out(1) => Branch on less than zero --OK
--[1] deco_1_out(2) => Jump--OK
--[2] deco_1_out(3) => Jump and Link --OK
--[3] deco_1_out(4) => Branch on equal--OK
--[4] deco_1_out(5) => Branch on not equal--OK
--[5] deco_1_out(8) => Add inmediate--OK
--[6] deco_1_out(10) => Set less than immediate--OK
--[7] deco_1_out(12) => AND immediate--OK
--[8] deco_1_out(13) => OR immediate--OK
--[9] deco_1_out(14) => XOR immediate--OK
--[10] deco_1_out(15) => Load Upper immediate
--[11] deco_1_out(35) => Load Word
--[12] deco_1_out(43) => Store Word
---------------------------------------------------------------------------------------------Entradas de data_decos_in provenientes de deco_2_control_unit
--[13]
--[14]
--[15]
--[16]
--[17]
--[18]
--[19]
--[20]
--[21]
--[22]
--[23]
--[24]
--[25]
--[26]
--[27]

deco_2_out(0) => shift left logical


deco_2_out(2) => Shift right logical
deco_2_out(3) => Shift right arithmetic
deco_2_out(4) => Shift left logical variable
deco_2_out(6) => Shift right logical variable
deco_2_out(7) => Shift right arith variable
deco_2_out(8) => Jump register
deco_2_out(12) => System call
deco_2_out(32) => Add
deco_2_out(34) => Substract
deco_2_out(36) => AND
deco_2_out(37) => OR
deco_2_out(38) => XOR
deco_2_out(39) => NOR
deco_2_out(42) => Set less than

Aux_signals_control_unit_test:Process
begin
data_decos_in<="0000000000000000000000000001";
wait for 10 ns;
data_decos_in<="0000000000000000000000000010";
wait for 10 ns;
data_decos_in<="0000000000000000000000000100";
wait for 10 ns;
data_decos_in<="0000000000000000000000001000";
wait for 10 ns;
data_decos_in<="0000000000000000000000010000";

77

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

wait for 10 ns;


data_decos_in<="0000000000000000000000100000";
wait for 10 ns;
data_decos_in<="0000000000000000000001000000";
wait for 10 ns;
data_decos_in<="0000000000000000000010000000";
wait for 10 ns;
data_decos_in<="0000000000000000000100000000";
wait for 10 ns;
data_decos_in<="0000000000000000001000000000";
wait for 10 ns;
data_decos_in<="0000000000000000010000000000";
wait for 10 ns;
data_decos_in<="0000000000000000100000000000";
wait for 10 ns;
data_decos_in<="0000000000000001000000000000";
wait for 10 ns;
data_decos_in<="0000000000000010000000000000";
wait for 10 ns;
data_decos_in<="0000000000000100000000000000";
wait for 10 ns;
data_decos_in<="0000000000001000000000000000";
wait for 10 ns;
data_decos_in<="0000000000010000000000000000";
wait for 10 ns;
data_decos_in<="0000000000100000000000000000";
wait for 10 ns;
data_decos_in<="0000000001000000000000000000";
wait for 10 ns;
data_decos_in<="0000000010000000000000000000";
wait for 10 ns;
data_decos_in<="0000000100000000000000000000";
wait for 10 ns;
data_decos_in<="0000001000000000000000000000";
wait for 10 ns;
data_decos_in<="0000010000000000000000000000";
wait for 10 ns;
data_decos_in<="0000100000000000000000000000";

78

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

wait for 10 ns;


data_decos_in<="0001000000000000000000000000";
wait for 10 ns;
data_decos_in<="0010000000000000000000000000";
wait for 10 ns;
data_decos_in<="0100000000000000000000000000";
wait for 10 ns;
data_decos_in<="1000000000000000000000000000";
wait for 10 ns;
end Process;

END;

4. Simulacion

Fig.34SimulacindeIaslneasauxiliaresdelaunidaddecontrol

79

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

CONTROLUNIT
1.

Definicin:
La unidad de control es el componente que integra a los dos decodificacoderes. La conexin en
cascada de estos dispositivos sirve para identificar las instrucciones.

2. CdigoenVHDLdelcomponente
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity control_unit is
Port ( cu_op_in : in STD_LOGIC_VECTOR (5 downto 0);
cu_fn_in : in STD_LOGIC_VECTOR (5 downto 0);
cu_RegWrite_out : out STD_LOGIC;
cu_RegDst_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_RegInSrc_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_ALUSrc_out : out STD_LOGIC;
cu_Add_sub_out : out STD_LOGIC;
cu_LogicFn_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_FnClass_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_DataRead_out : out STD_LOGIC;
cu_DataWrite_out : out STD_LOGIC;
cu_BrType_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_PCSrc_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_ConstantVar_out : out STD_LOGIC;
cu_ShiftFn_out : out STD_LOGIC_VECTOR (1 downto 0));
end control_unit;
architecture Behavioral of control_unit is
component deco_1_control_unit
Port (
deco_1_enable_in : in STD_LOGIC;
deco_1_op_in : in STD_LOGIC_VECTOR (5 downto 0);
deco_1_out : out STD_LOGIC_VECTOR (63 downto 0));
end component;
component deco_2_control_unit
Port (
deco_2_enable_in : in STD_LOGIC;
deco_2_fn_in : in STD_LOGIC_VECTOR (5 downto 0);
deco_2_out : out STD_LOGIC_VECTOR (63 downto 0));
end component;

80

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

component aux_signals_control_unit
Port (
data_decos_in : in STD_LOGIC_VECTOR (27 downto 0);
RegWrite : out STD_LOGIC;
RegDst : out STD_LOGIC_VECTOR (1 downto 0);
RegInSrc : out STD_LOGIC_VECTOR (1 downto 0);
ALUSrc : out STD_LOGIC;
Add_sub : out STD_LOGIC;
LogicFn : out STD_LOGIC_VECTOR (1 downto 0);
FnClass : out STD_LOGIC_VECTOR (1 downto 0);
DataRead : out STD_LOGIC;
DataWrite : out STD_LOGIC;
BrType : out STD_LOGIC_VECTOR (1 downto 0);
PCSrc : out STD_LOGIC_VECTOR (1 downto 0);
ConstantVar : out STD_LOGIC;
ShiftFn : out STD_LOGIC_VECTOR (1 downto 0));
end component;
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal

sig0:STD_LOGIC;
sig1:STD_LOGIC;
sig2:STD_LOGIC;
sig3:STD_LOGIC;
sig4:STD_LOGIC;
sig5:STD_LOGIC;
sig6:STD_LOGIC;
sig7:STD_LOGIC;
sig8:STD_LOGIC;
sig9:STD_LOGIC;
sig10:STD_LOGIC;
sig11:STD_LOGIC;
sig12:STD_LOGIC;
sig13:STD_LOGIC;
sig14:STD_LOGIC;

signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal

sig15:STD_LOGIC;
sig16:STD_LOGIC;
sig17:STD_LOGIC;
sig18:STD_LOGIC;
sig19:STD_LOGIC;
sig20:STD_LOGIC;
sig21:STD_LOGIC;
sig22:STD_LOGIC;
sig23:STD_LOGIC;
sig24:STD_LOGIC;
sig25:STD_LOGIC;
sig26:STD_LOGIC;
sig27:STD_LOGIC;
sig28:STD_LOGIC;
bits_no_usados:STD_LOGIC_VECTOR(97 downto 0);

--[0]
--[1]
--[2]
--[3]
--[4]
--[5]

deco_1_out(1)
deco_1_out(2)
deco_1_out(3)
deco_1_out(4)
deco_1_out(5)
deco_1_out(8)

81

=>
=>
=>
=>
=>
=>

Branch on less than zero


Jump
Jump and Link
Branch on equal
Branch on not equal
Add inmediate

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--[6] deco_1_out(10) => Set less than immediate


--[7] deco_1_out(12) => AND immediate
--[8] deco_1_out(13) => OR immediate
--[9] deco_1_out(14) => XOR immediate
--[10] deco_1_out(15) => Load Upper immediate
--[11] deco_1_out(35) => Load Word
--[12] deco_1_out(43) => Store Word
---------------------------------------------------------------------------------------------Entradas de data_decos_in provenientes de deco_2_control_unit
--[13]
--[14]
--[15]
--[16]
--[17]
--[18]
--[19]
--[20]
--[21]
--[22]
--[23]
--[24]
--[25]
--[26]
--[27]

deco_2_out(0) => shift left logical


deco_2_out(2) => Shift right logical
deco_2_out(3) => Shift right arithmetic
deco_2_out(4) => Shift left logical variable
deco_2_out(6) => Shift right logical variable
deco_2_out(7) => Shift right arith variable
deco_2_out(8) => Jump register
deco_2_out(12) => System call
deco_2_out(32) => Add
deco_2_out(34) => Substract
deco_2_out(36) => AND
deco_2_out(37) => OR
deco_2_out(38) => XOR
deco_2_out(39) => NOR
deco_2_out(42) => Set less than

begin
deco_1_control_unit_1:deco_1_control_unit
PORT MAP (
deco_1_enable_in =>'1',
deco_1_op_in => cu_op_in,
deco_1_out(0) => sig0,
deco_1_out(1) => sig1,
deco_1_out(2) => sig2,
deco_1_out(3) => sig3,
deco_1_out(4) => sig4,
deco_1_out(5) => sig5,
deco_1_out(7 downto 6) => bits_no_usados(1 downto 0),
deco_1_out(8) => sig6,
deco_1_out(9) => bits_no_usados(2),
deco_1_out(10) => sig7,
deco_1_out(11) => bits_no_usados(3),
deco_1_out(12) => sig8,
deco_1_out(13) => sig9,
deco_1_out(14) => sig10,
deco_1_out(15) => sig11,
deco_1_out(34 downto 16) => bits_no_usados(22 downto 4),
deco_1_out(35) => sig12,
deco_1_out(42 downto 36) => bits_no_usados(29 downto 23),
deco_1_out(43) => sig13,
deco_1_out(63 downto 44) => bits_no_usados(49 downto 30)
);
deco_2_control_unit_1:deco_2_control_unit
PORT MAP (

82

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

deco_2_enable_in =>sig0,
deco_2_fn_in => cu_fn_in,
deco_2_out(0) => sig14,
deco_2_out(1) => bits_no_usados(50),
deco_2_out(2) => sig15,
deco_2_out(3) => sig16,
deco_2_out(4) => sig17,
deco_2_out(5) => bits_no_usados(51),
deco_2_out(6) => sig18,
deco_2_out(7) => sig19,
deco_2_out(8) => sig20,
deco_2_out(11 downto 9) => bits_no_usados(53 downto 51),
deco_2_out(12) => sig21,
deco_2_out(31 downto 13) => bits_no_usados(72 downto 54),
deco_2_out(32) => sig22,
deco_2_out(33) => bits_no_usados(73),
deco_2_out(34) => sig23,
deco_2_out(35) => bits_no_usados(74),
deco_2_out(36) => sig24,
deco_2_out(37) => sig25,
deco_2_out(38) => sig26,
deco_2_out(39) => sig27,
deco_2_out(41 downto 40) => bits_no_usados(76 downto 75),
deco_2_out(42) => sig28,
deco_2_out(63 downto 43) => bits_no_usados(97 downto 77)
);
aux_signals_control_unit_1:aux_signals_control_unit
PORT MAP (
data_decos_in(0) => sig1,
data_decos_in(1) => sig2,
data_decos_in(2) => sig3,
data_decos_in(3) => sig4,
data_decos_in(4) => sig5,
data_decos_in(5) => sig6,
data_decos_in(6) => sig7,
data_decos_in(7) => sig8,
data_decos_in(8) => sig9,
data_decos_in(9) => sig10,
data_decos_in(10) => sig11,
data_decos_in(11) => sig12,
data_decos_in(12) => sig13,
data_decos_in(13) => sig14,
data_decos_in(14) => sig15,
data_decos_in(15) => sig16,
data_decos_in(16) => sig17,
data_decos_in(17) => sig18,
data_decos_in(18) => sig19,
data_decos_in(19) => sig20,
data_decos_in(20) => sig21,
data_decos_in(21) => sig22,
data_decos_in(22) => sig23,
data_decos_in(23) => sig24,
data_decos_in(24) => sig25,
data_decos_in(25) => sig26,
data_decos_in(26) => sig27,
data_decos_in(27) => sig28,

83

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

RegWrite => cu_RegWrite_out,


RegDst => cu_RegDst_out,
RegInSrc => cu_RegInSrc_out,
ALUSrc => cu_ALUSrc_out,
Add_sub => cu_Add_sub_out,
LogicFn => cu_LogicFn_out,
FnClass => cu_FnClass_out,
DataRead => cu_DataRead_out,
DataWrite => cu_DataWrite_out,
BrType => cu_BrType_out,
PCSrc => cu_PCSrc_out,
ConstantVar => cu_ConstantVar_out,
ShiftFn => cu_ShiftFn_out
);
end Behavioral;

3. Bancodeprueba
-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY control_unit_tb IS
END control_unit_tb;
ARCHITECTURE behavior OF control_unit_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT control_unit
PORT(
cu_op_in : IN std_logic_vector(5 downto 0);
cu_fn_in : IN std_logic_vector(5 downto 0);
cu_RegWrite_out : OUT std_logic;
cu_RegDst_out : OUT std_logic_vector(1 downto 0);
cu_RegInSrc_out : OUT std_logic_vector(1 downto 0);
cu_ALUSrc_out : OUT std_logic;
cu_Add_sub_out : OUT std_logic;
cu_LogicFn_out : OUT std_logic_vector(1 downto 0);
cu_FnClass_out : OUT std_logic_vector(1 downto 0);
cu_DataRead_out : OUT std_logic;
cu_DataWrite_out : OUT std_logic;
cu_BrType_out : OUT std_logic_vector(1 downto 0);
cu_PCSrc_out : OUT std_logic_vector(1 downto 0);
cu_ConstantVar_out : OUT std_logic;
cu_ShiftFn_out : OUT std_logic_vector(1 downto 0)
);
END COMPONENT;

--Inputs
signal cu_op_in : std_logic_vector(5 downto 0) := (others => '0');
signal cu_fn_in : std_logic_vector(5 downto 0) := (others => '0');

84

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

--Outputs
signal cu_RegWrite_out : std_logic;
signal cu_RegDst_out : std_logic_vector(1 downto 0);
signal cu_RegInSrc_out : std_logic_vector(1 downto 0);
signal cu_ALUSrc_out : std_logic;
signal cu_Add_sub_out : std_logic;
signal cu_LogicFn_out : std_logic_vector(1 downto 0);
signal cu_FnClass_out : std_logic_vector(1 downto 0);
signal cu_DataRead_out : std_logic;
signal cu_DataWrite_out : std_logic;
signal cu_BrType_out : std_logic_vector(1 downto 0);
signal cu_PCSrc_out : std_logic_vector(1 downto 0);
signal cu_ConstantVar_out : std_logic;
signal cu_ShiftFn_out : std_logic_vector(1 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: control_unit PORT MAP (
cu_op_in => cu_op_in,
cu_fn_in => cu_fn_in,
cu_RegWrite_out => cu_RegWrite_out,
cu_RegDst_out => cu_RegDst_out,
cu_RegInSrc_out => cu_RegInSrc_out,
cu_ALUSrc_out => cu_ALUSrc_out,
cu_Add_sub_out => cu_Add_sub_out,
cu_LogicFn_out => cu_LogicFn_out,
cu_FnClass_out => cu_FnClass_out,
cu_DataRead_out => cu_DataRead_out,
cu_DataWrite_out => cu_DataWrite_out,
cu_BrType_out => cu_BrType_out,
cu_PCSrc_out => cu_PCSrc_out,
cu_ConstantVar_out => cu_ConstantVar_out,
cu_ShiftFn_out => cu_ShiftFn_out
);
Control_unit_test:Process
begin
--Load upper immediate
cu_op_in <="001111";
cu_fn_in <="000000";
wait for 10 ns;
--Add
cu_op_in <="000000";
cu_fn_in <="100000";
wait for 10 ns;
--Subtract
cu_op_in <="000000";
cu_fn_in <="100010";
wait for 10 ns;
--Set less than
cu_op_in <="000000";
cu_fn_in <="101010";
wait for 10 ns;
--Add immediate

85

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

cu_op_in <="001000";
cu_fn_in <="000000";
wait for 10 ns;
--Set less than immediate
cu_op_in <="001010";
cu_fn_in <="000000";
wait for 10 ns;
--AND
cu_op_in <="000000";
cu_fn_in <="100100";
wait for 10 ns;
--OR
cu_op_in <="000000";
cu_fn_in <="100101";
wait for 10 ns;
--XOR
cu_op_in <="000000";
cu_fn_in <="100110";
wait for 10 ns;
--NOR
cu_op_in <="000000";
cu_fn_in <="100111";
wait for 10 ns;
--AND immediate
cu_op_in <="001100";
cu_fn_in <="000000";
wait for 10 ns;
--OR immediate
cu_op_in <="001101";
cu_fn_in <="000000";
wait for 10 ns;
--XOR immediate
cu_op_in <="001110";
cu_fn_in <="000000";
wait for 10 ns;
--Load word
cu_op_in <="100011";
cu_fn_in <="000000";
wait for 10 ns;
--Store word
cu_op_in <="101011";
cu_fn_in <="001000";
wait for 10 ns;
--Jump
cu_op_in <="000010";
cu_fn_in <="000000";

86

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

wait for 10 ns;


--Jump register
cu_op_in <="000000";
cu_fn_in <="001000";
wait for 10 ns;
--Branch
cu_op_in
cu_fn_in
wait for

on less than zero


<="000001";
<="000000";
10 ns;

--Branch
cu_op_in
cu_fn_in
wait for

on equal
<="000100";
<="000000";
10 ns;

--Branch
cu_op_in
cu_fn_in
wait for

on not equal
<="000101";
<="001100";
10 ns;

--Jump and Link


cu_op_in <="000011";
cu_fn_in <="000000";
wait for 10 ns;

-- System call
cu_op_in <="000000";
cu_fn_in <="001100";
wait for 10 ns;
end Process;
END;

4. Simulacin

Fig.35SimulacindeIaUnidaddeControl

87

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

DatapathyUnidaddeControl
1. CodigodelcomponenteenVHDL
---------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity datapath_controlunit is
Port ( dp_cu_clk_in : in STD_LOGIC;
dp_cu_clk_50Mhz_in : in STD_LOGIC;
dp_cu_Reg_T0_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_Reg_T1_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_Reg_T3_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_op_out : out STD_LOGIC_VECTOR (5 downto 0);
test_alu_out:out STD_LOGIC_VECTOR(31 downto 0);
test_constant_amount:out STD_LOGIC_VECTOR (4 downto 0);
test_y_alu:out STD_LOGIC_VECTOR(31 downto 0);
test_rs:out STD_LOGIC_VECTOR(31 downto 0);
test_rt:out STD_LOGIC_VECTOR(31 downto 0);
test_im:out STD_LOGIC_VECTOR(31 downto 0);
test_Pc_in:out STD_LOGIC_VECTOR(29 downto 0);
test_Pc_out:out STD_LOGIC_VECTOR(29 downto 0);
sigPCSrc:out STD_LOGIC_VECTOR(1 downto 0);
sigBrType:out STD_LOGIC_VECTOR(1 downto 0);
sigDataWrite:out STD_LOGIC;
sigDataRead:out STD_LOGIC;
sigfunction_class:out STD_LOGIC_VECTOR(1 downto 0);
siglogic_function:out STD_LOGIC_VECTOR(1 downto 0);
sigadd_sub:out STD_LOGIC;
sigALUSrc:out STD_LOGIC;
sigRegInSrc:out STD_LOGIC_VECTOR(1 downto 0);
sigRegDst:out STD_LOGIC_VECTOR(1 downto 0);
sigRegWrite:out STD_LOGIC;
sigconstant_var:out STD_LOGIC;
sigshift_function:out STD_LOGIC_VECTOR(1 downto 0);
test_instruc_out: out STD_LOGIC_VECTOR(31 downto 0);
REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el
corrimiento a la izquierda
REG_T5: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el
corrimiento a la derecha

88

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

dp_cu_fn_out : out
end datapath_controlunit;

STD_LOGIC_VECTOR (5 downto 0));

architecture Behavioral of datapath_controlunit is


component clock_buffer
port
(
clk
:
btn
:
clk_o :
);
end component;

in
in
out

std_logic;
std_logic;
std_logic

component datapath
Port (
clk_RegFile : in STD_LOGIC;
clk_PC : in STD_LOGIC;
PCSrc : in STD_LOGIC_VECTOR (1 downto 0);
BrType : in STD_LOGIC_VECTOR (1 downto 0);
RegDst : in STD_LOGIC_VECTOR (1 downto 0);
RegWrite : in STD_LOGIC;
ALUSrc : in STD_LOGIC;
add_sub : in STD_LOGIC;
logic_function : in STD_LOGIC_VECTOR (1 downto 0);
function_class : in STD_LOGIC_VECTOR (1 downto 0);
--constant_amount : in STD_LOGIC_VECTOR (4 downto 0);
constant_var : in STD_LOGIC;
shift_function : in STD_LOGIC_VECTOR (1 downto 0);
DataRead : in STD_LOGIC;
DataWrite : in STD_LOGIC;
RegInSrc : in STD_LOGIC_VECTOR (1 downto 0);
op : out STD_LOGIC_VECTOR (5 downto 0);
fn : out STD_LOGIC_VECTOR (5 downto 0);
--verificando salida de la alu
test_alu_out:out STD_LOGIC_VECTOR(31 downto 0);
test_constant_amount:out STD_LOGIC_VECTOR (4 downto 0);
test_y_alu:out STD_LOGIC_VECTOR(31 downto 0);
test_rs:out STD_LOGIC_VECTOR(31 downto 0);
test_rt:out STD_LOGIC_VECTOR(31 downto 0);
test_im:out STD_LOGIC_VECTOR(31 downto 0);
--test_pc
test_Pc_in:out STD_LOGIC_VECTOR(29 downto 0);
test_Pc_out:out STD_LOGIC_VECTOR(29 downto 0);
test_instruc_out: out STD_LOGIC_VECTOR(31 downto 0);
--Muestreando el registro para ver los
REG_T0: out STD_LOGIC_VECTOR(31 downto
REG_T1: out STD_LOGIC_VECTOR(31 downto
REG_T3: out STD_LOGIC_VECTOR(31 downto

valores de fibonacci
0);
0);
0);

REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el


corrimiento a la izquierda

89

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

REG_T5: out STD_LOGIC_VECTOR(31 downto 0)--aqui vere el corrimiento


a la derecha
);
end component;
component control_unit
Port (
cu_op_in : in STD_LOGIC_VECTOR (5 downto 0);
cu_fn_in : in STD_LOGIC_VECTOR (5 downto 0);
cu_RegWrite_out : out STD_LOGIC;
cu_RegDst_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_RegInSrc_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_ALUSrc_out : out STD_LOGIC;
cu_Add_sub_out : out STD_LOGIC;
cu_LogicFn_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_FnClass_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_DataRead_out : out STD_LOGIC;
cu_DataWrite_out : out STD_LOGIC;
cu_BrType_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_PCSrc_out : out STD_LOGIC_VECTOR (1 downto 0);
cu_ConstantVar_out : out STD_LOGIC;
cu_ShiftFn_out : out STD_LOGIC_VECTOR (1 downto 0));
end component;
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal

sig0: STD_LOGIC;
sig1: STD_LOGIC_VECTOR (1 downto 0);
sig2: STD_LOGIC_VECTOR (1 downto 0);
sig3: STD_LOGIC;
sig4: STD_LOGIC;
sig5: STD_LOGIC_VECTOR (1 downto 0);
sig6: STD_LOGIC_VECTOR (1 downto 0);
sig7: STD_LOGIC;
sig8: STD_LOGIC;
sig9: STD_LOGIC_VECTOR (1 downto 0);
sig10: STD_LOGIC_VECTOR (1 downto 0);
sig11: STD_LOGIC;
sig12: STD_LOGIC;
sig13: STD_LOGIC_VECTOR (1 downto 0);
sig14: STD_LOGIC_VECTOR (5 downto 0);
sig15: STD_LOGIC_VECTOR (5 downto 0);

begin
clock_buffer_1:clock_buffer
port map(
clk
=> dp_cu_clk_50Mhz_in,
btn
=> dp_cu_clk_in,
clk_o => sig0
);
datapath_1:datapath
PORT MAP (
clk_RegFile => dp_cu_clk_50Mhz_in,
clk_PC => sig0,--Mas lento que el de 50 Mhz
PCSrc => sig1,
BrType => sig2,
DataWrite => sig3,

90

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

DataRead => sig4,


function_class => sig5,
logic_function => sig6,
add_sub => sig7,
ALUSrc => sig8,
RegInSrc => sig9,
RegDst => sig10,
RegWrite => sig11,
constant_var => sig12,
shift_function => sig13,
op => sig14,
fn => sig15,
test_alu_out=>test_alu_out,
test_constant_amount=>test_constant_amount,
test_y_alu=>test_y_alu,
test_rs=>test_rs,
test_rt=>test_rt,
test_im=>test_im,
test_Pc_in=>test_Pc_in,
test_Pc_out=>test_Pc_out,
test_instruc_out=>test_instruc_out,
REG_T0=> dp_cu_Reg_T0_out,
REG_T1=> dp_cu_Reg_T1_out,
REG_T3=> dp_cu_Reg_T3_out,
REG_T4=>REG_T4,
REG_T5=>REG_T5
);
control_unit_1:control_unit
PORT MAP (
cu_op_in => sig14,
cu_fn_in => sig15,
cu_RegWrite_out => sig11,
cu_RegDst_out => sig10,
cu_RegInSrc_out => sig9,
cu_ALUSrc_out => sig8,
cu_Add_sub_out => sig7,
cu_LogicFn_out => sig6,
cu_FnClass_out => sig5,
cu_DataRead_out => sig4,
cu_DataWrite_out => sig3,
cu_BrType_out => sig2,
cu_PCSrc_out => sig1,
cu_ConstantVar_out => sig12,
cu_ShiftFn_out => sig13
);
dp_cu_op_out<=sig14;
dp_cu_fn_out<=sig15;
sigPCSrc<= sig1;
sigBrType<=sig2;
sigDataWrite<= sig3;

91

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

sigDataRead<= sig4;
sigfunction_class<= sig5;
siglogic_function<= sig6;
sigadd_sub<= sig7;
sigALUSrc<= sig8;
sigRegInSrc<= sig9;
sigRegDst<= sig10;
sigRegWrite<= sig11;
sigconstant_var<= sig12;
sigshift_function<= sig13;
end Behavioral;

2. Bancodepruebas
-------------------------------------------------------------------------------LIBRARY ieee;
USE ieee.std_logic_1164.ALL;
USE ieee.std_logic_unsigned.all;
USE ieee.numeric_std.ALL;
ENTITY datapath_controlunit_tb IS
END datapath_controlunit_tb;
ARCHITECTURE behavior OF datapath_controlunit_tb IS
-- Component Declaration for the Unit Under Test (UUT)
COMPONENT datapath_controlunit
PORT(
dp_cu_clk_in : IN std_logic;
dp_cu_clk_50Mhz_in : IN std_logic;
dp_cu_Reg_T0_out : OUT std_logic_vector(31 downto 0);
dp_cu_Reg_T1_out : OUT std_logic_vector(31 downto 0);
dp_cu_Reg_T3_out : OUT std_logic_vector(31 downto 0);
dp_cu_op_out : OUT std_logic_vector(5 downto 0);
test_alu_out : OUT std_logic_vector(31 downto 0);
test_constant_amount : OUT std_logic_vector(4 downto 0);
test_y_alu : OUT std_logic_vector(31 downto 0);
test_rs : OUT std_logic_vector(31 downto 0);
test_rt : OUT std_logic_vector(31 downto 0);
test_im : OUT std_logic_vector(31 downto 0);
test_Pc_in : OUT std_logic_vector(29 downto 0);
test_Pc_out : OUT std_logic_vector(29 downto 0);
sigPCSrc : OUT std_logic_vector(1 downto 0);
sigBrType : OUT std_logic_vector(1 downto 0);
sigDataWrite : OUT std_logic;
sigDataRead : OUT std_logic;
sigfunction_class : OUT std_logic_vector(1 downto 0);
siglogic_function : OUT std_logic_vector(1 downto 0);
sigadd_sub : OUT std_logic;
sigALUSrc : OUT std_logic;
sigRegInSrc : OUT std_logic_vector(1 downto 0);
sigRegDst : OUT std_logic_vector(1 downto 0);
sigRegWrite : OUT std_logic;

92

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

sigconstant_var : OUT std_logic;


sigshift_function : OUT std_logic_vector(1 downto 0);
test_instruc_out : OUT std_logic_vector(31 downto 0);
REG_T4 : OUT std_logic_vector(31 downto 0);
REG_T5 : OUT std_logic_vector(31 downto 0);
dp_cu_fn_out : OUT std_logic_vector(5 downto 0)
);
END COMPONENT;

--Inputs
signal dp_cu_clk_in : std_logic := '0';
signal dp_cu_clk_50Mhz_in : std_logic := '0';
--Outputs
signal dp_cu_Reg_T0_out : std_logic_vector(31 downto 0);
signal dp_cu_Reg_T1_out : std_logic_vector(31 downto 0);
signal dp_cu_Reg_T3_out : std_logic_vector(31 downto 0);
signal dp_cu_op_out : std_logic_vector(5 downto 0);
signal test_alu_out : std_logic_vector(31 downto 0);
signal test_constant_amount : std_logic_vector(4 downto 0);
signal test_y_alu : std_logic_vector(31 downto 0);
signal test_rs : std_logic_vector(31 downto 0);
signal test_rt : std_logic_vector(31 downto 0);
signal test_im : std_logic_vector(31 downto 0);
signal test_Pc_in : std_logic_vector(29 downto 0);
signal test_Pc_out : std_logic_vector(29 downto 0);
signal sigPCSrc : std_logic_vector(1 downto 0);
signal sigBrType : std_logic_vector(1 downto 0);
signal sigDataWrite : std_logic;
signal sigDataRead : std_logic;
signal sigfunction_class : std_logic_vector(1 downto 0);
signal siglogic_function : std_logic_vector(1 downto 0);
signal sigadd_sub : std_logic;
signal sigALUSrc : std_logic;
signal sigRegInSrc : std_logic_vector(1 downto 0);
signal sigRegDst : std_logic_vector(1 downto 0);
signal sigRegWrite : std_logic;
signal sigconstant_var : std_logic;
signal sigshift_function : std_logic_vector(1 downto 0);
signal test_instruc_out : std_logic_vector(31 downto 0);
signal REG_T4 : std_logic_vector(31 downto 0);
signal REG_T5 : std_logic_vector(31 downto 0);
signal dp_cu_fn_out : std_logic_vector(5 downto 0);
BEGIN
-- Instantiate the Unit Under Test (UUT)
uut: datapath_controlunit PORT MAP (
dp_cu_clk_in => dp_cu_clk_in,
dp_cu_clk_50Mhz_in => dp_cu_clk_50Mhz_in,
dp_cu_Reg_T0_out => dp_cu_Reg_T0_out,
dp_cu_Reg_T1_out => dp_cu_Reg_T1_out,
dp_cu_Reg_T3_out => dp_cu_Reg_T3_out,
dp_cu_op_out => dp_cu_op_out,
test_alu_out => test_alu_out,
test_constant_amount => test_constant_amount,

93

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

test_y_alu => test_y_alu,


test_rs => test_rs,
test_rt => test_rt,
test_im => test_im,
test_Pc_in => test_Pc_in,
test_Pc_out => test_Pc_out,
sigPCSrc => sigPCSrc,
sigBrType => sigBrType,
sigDataWrite => sigDataWrite,
sigDataRead => sigDataRead,
sigfunction_class => sigfunction_class,
siglogic_function => siglogic_function,
sigadd_sub => sigadd_sub,
sigALUSrc => sigALUSrc,
sigRegInSrc => sigRegInSrc,
sigRegDst => sigRegDst,
sigRegWrite => sigRegWrite,
sigconstant_var => sigconstant_var,
sigshift_function => sigshift_function,
test_instruc_out => test_instruc_out,
REG_T4 => REG_T4,
REG_T5 => REG_T5,
dp_cu_fn_out => dp_cu_fn_out
);

clk_50Mhz_test: Process
begin
dp_cu_clk_50Mhz_in <= not dp_cu_clk_50Mhz_in;
wait for 100 ns;
end Process;
clk_test:Process
begin
dp_cu_clk_in <= not dp_cu_clk_in;
wait for 1200 ns;
end Process;

END;

3. Simulacion

94

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

95

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

Procesador
----------------------------------------------------------------------------------- Company:
-- Engineer:
--- Create Date:
09:40:24 06/13/2010
-- Design Name:
-- Module Name:
processor - Behavioral
-- Project Name:
-- Target Devices:
-- Tool versions:
-- Description:
--- Dependencies:
--- Revision:
-- Revision 0.01 - File Created
-- Additional Comments:
----------------------------------------------------------------------------------library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
---- Uncomment the following library declaration if instantiating
---- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;
entity processor is
Port ( p_clk_in : in STD_LOGIC;
clk_50_Mhz_in : in STD_LOGIC;
processor_out : out STD_LOGIC_VECTOR (7 downto 0));
end processor;
architecture Behavioral of processor is
component datapath_controlunit
Port ( dp_cu_clk_in : in STD_LOGIC;
dp_cu_clk_50Mhz_in : in STD_LOGIC;
dp_cu_Reg_T0_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_Reg_T1_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_Reg_T3_out : out STD_LOGIC_VECTOR (31 downto 0);
dp_cu_op_out : out STD_LOGIC_VECTOR (5 downto 0);
test_alu_out:out STD_LOGIC_VECTOR(31 downto 0);
test_constant_amount:out STD_LOGIC_VECTOR (4 downto 0);
test_y_alu:out STD_LOGIC_VECTOR(31 downto 0);
test_rs:out STD_LOGIC_VECTOR(31 downto 0);
test_rt:out STD_LOGIC_VECTOR(31 downto 0);
test_im:out STD_LOGIC_VECTOR(31 downto 0);
test_Pc_in:out STD_LOGIC_VECTOR(29 downto 0);

96

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

test_Pc_out:out STD_LOGIC_VECTOR(29 downto 0);


sigPCSrc:out STD_LOGIC_VECTOR(1 downto 0);
sigBrType:out STD_LOGIC_VECTOR(1 downto 0);
sigDataWrite:out STD_LOGIC;
sigDataRead:out STD_LOGIC;
sigfunction_class:out STD_LOGIC_VECTOR(1 downto 0);
siglogic_function:out STD_LOGIC_VECTOR(1 downto 0);
sigadd_sub:out STD_LOGIC;
sigALUSrc:out STD_LOGIC;
sigRegInSrc:out STD_LOGIC_VECTOR(1 downto 0);
sigRegDst:out STD_LOGIC_VECTOR(1 downto 0);
sigRegWrite:out STD_LOGIC;
sigconstant_var:out STD_LOGIC;
sigshift_function:out STD_LOGIC_VECTOR(1 downto 0);
test_instruc_out: out STD_LOGIC_VECTOR(31 downto 0);
REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el
corrimiento a la izquierda
REG_T5: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el
corrimiento a la derecha
dp_cu_fn_out : out

STD_LOGIC_VECTOR (5 downto 0));

end component;
signal temp:STD_LOGIC_VECTOR (23 downto 0);
begin
datapath_controlunit_1:datapath_controlunit
PORT MAP (
dp_cu_clk_in => p_clk_in,
dp_cu_clk_50Mhz_in => clk_50_Mhz_in ,
dp_cu_Reg_T0_out => open,
dp_cu_Reg_T1_out => open,
dp_cu_Reg_T3_out(7 downto 0) => processor_out(7 downto 0),
dp_cu_Reg_T3_out(31 downto 8) => temp(23 downto 0),
dp_cu_op_out => open,
test_alu_out => open,
test_constant_amount => open,
test_y_alu => open,
test_rs => open,
test_rt => open,
test_im => open,
test_Pc_in => open,
test_Pc_out => open,
sigPCSrc => open,
sigBrType => open,
sigDataWrite => open,
sigDataRead => open,
sigfunction_class => open,
siglogic_function => open,
sigadd_sub => open,
sigALUSrc => open,
sigRegInSrc => open,

97

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

ExposicinTecnolgicayCientfica

ETyC2010

sigRegDst => open,


sigRegWrite => open,
sigconstant_var => open,
sigshift_function => open,
test_instruc_out => open,
REG_T4 => open,
REG_T5 => open,
dp_cu_fn_out => open
);
end Behavioral;

UserConstraintsFile
######### Pin assignments for top_sequence ###########
## The Spartan 3E's 50 MHz clock is used in the clock buffer.
NET "clk_50_Mhz_in"

LOC = "C9";

# CLK_50MHZ

## 'RESET' and 'btn_clk' are tied to buttons


## The 'PULLDOWN' constraint makes the button return a
## low when it is released, otherwise it will float.
NET "p_clk_in" LOC = "K17"

| PULLDOWN ;

# BTN_NORTH

## The data input will be controlled with a switch


## Outputs are routed to the LED's
NET
NET
NET
NET
NET
NET
NET
NET

"procesor_out<7>"
"procesor_out<6>"
"procesor_out<5>"
"procesor_out<4>"
"procesor_out<3>"
"procesor_out<2>"
"procesor_out<1>"
"procesor_out<0>"

98

LOC
LOC
LOC
LOC
LOC
LOC
LOC
LOC

=
=
=
=
=
=
=
=

"F9"
"E9"
"D11"
"C11"
"F11"
"E11"
"E12"
"F12"

|
|
|
|
|
|
|
|

IOSTANDARD
IOSTANDARD
IOSTANDARD
IOSTANDARD
IOSTANDARD
IOSTANDARD
IOSTANDARD
IOSTANDARD

=
=
=
=
=
=
=
=

LVTTL
LVTTL
LVTTL
LVTTL
LVTTL
LVTTL
LVTTL
LVTTL

|
|
|
|
|
|
|
|

SLEW
SLEW
SLEW
SLEW
SLEW
SLEW
SLEW
SLEW

=
=
=
=
=
=
=
=

SLOW
SLOW
SLOW
SLOW
SLOW
SLOW
SLOW
SLOW

|
|
|
|
|
|
|
|

DRIVE
DRIVE
DRIVE
DRIVE
DRIVE
DRIVE
DRIVE
DRIVE

Tutorial:Implementaciondeunprocesadorderutadedatossencilla

=
=
=
=
=
=
=
=

8
8
8
8
8
8
8
8

;
;
;
;
;
;
;
;