Curso ETyC Raul Peralta

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
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.
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.
4.
CdigodelComponenteenVHDL:................................................................................23
5.
Bancodepruebas:.........................................................................................................23
6.
Simulacin:....................................................................................................................25
EXTENSINDESIGNO...................................................................................................................26
1.
Definicin:.....................................................................................................................26
2.
Implementacin:...........................................................................................................26
3.
4.
CdigodelcomponenteenVHDL:................................................................................27
5.
Bancodepruebas:.........................................................................................................27
6.
Simulacin:....................................................................................................................28
ETyC2010
ImplementacinysimulacindelaALUenVHDL............................................................................29
SUMADORTOTALDEUNBIT.........................................................................................................29
1.
Definicin:.....................................................................................................................29
2.
Implementacin:...........................................................................................................29
3.
4.
5.
Bancodeprueba:..........................................................................................................31
6.
Simulacin:....................................................................................................................32
SUMADORTOTALDE32BITS........................................................................................................33
1.
Definicin:.....................................................................................................................33
2.
Implementacin:...........................................................................................................33
3.
4.
5.
Bancodeprueba:..........................................................................................................36
6.
Simulacin:....................................................................................................................37
LaUnidadaritmticalgica...............................................................................................................38
ImplementacindelaALU............................................................................................................38
1.
Definicin:.....................................................................................................................38
2.
Implementacin:...........................................................................................................38
3.
4.
5.
Bancodeprueba:..........................................................................................................40
6.
Simulacin:....................................................................................................................42
Bloquedecontadordeprograma(PC)yelbloquequecalculalasiguientedireccin(NEXT
ADDRESS)..........................................................................................................................................43
PC(Contadordeprograma)..........................................................................................................43
1.
Definicin:.....................................................................................................................43
2.
Implementacin:...........................................................................................................43
3.
4.
5.
Bancodeprueba:..........................................................................................................44
6.
Simulacin:....................................................................................................................45
NEXTADDRESS(siguientedireccin)............................................................................................46
ETyC2010
1.
2.
3.
4.
5.
6.
Definicin:.....................................................................................................................46
Implementacin:...........................................................................................................46
Bancodeprueba:..........................................................................................................48
Simulacin:....................................................................................................................50
Sntesisysimulacindelarutadedatos..........................................................................................52
Introduccin..................................................................................................................................52
1.
2.
Bancodeprueba:..........................................................................................................57
3.
Simulacin.....................................................................................................................61
Derivacindelassealesdecontrol.................................................................................................62
ImplementacinysimulacinenVHDLdelaunidaddecontrol.Bloques:decodificadores,circuitos
combinacionales................................................................................................................................62
DecodificadordeInstrucciones1..................................................................................................65
1.
Definicin:.....................................................................................................................65
2.
Implementacin:...........................................................................................................65
3.
4.
5.
Bancodeprueba:..........................................................................................................66
6.
Simulacin.....................................................................................................................68
DecodificadordeInstrucciones2..................................................................................................69
1.
Definicin:.....................................................................................................................69
2.
Implementacin:...........................................................................................................69
3.
4.
5.
Bancodepruebas..........................................................................................................70
6.
Simulacin.....................................................................................................................72
1.
Definicion:.....................................................................................................................73
2.CdigodelcomponenteenVHDL.........................................................................................73
3.
Bancodeprueba...........................................................................................................75
4.
Simulacion.....................................................................................................................79
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
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
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
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
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
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
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
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
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
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
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
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
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 =>

when VALUE_2 | VALUE_3
=>
-- | = OR
when VALUE_4 to VALUE_N =>

-- to = range
when
others =>
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
ETyC2010

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
direccion 2
--Muestreando el registro para ver los
REG_T0: 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";
--completar!!
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
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_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
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);
-- 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';
clk <= '0';
end Process;
Data : Process
Begin
data_in <="00000000000000000000000000000001";
wait for CLK_PERIOD*4;
data_in <="00000000000000000000000000000010";
end Process;
Clocks : Process
Begin
20
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
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.
a)
if: instruccin de bifurcacin. Dependiendo de si la condicin es verdadera o falsa se ejecuta un

if CONDITION then
else
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 =>

22
when VALUE_2 | VALUE_3

=>
-- | = OR
when
-- to = range
VALUE_4 to VALUE_N
=>
ETyC2010
when
others =>
end
4.
case ;
CdigodelComponenteenVHDL:
-------------------------------------------------------------------------library IEEE;
--library UNISIM;
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);
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;
23
ETyC2010
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 mux_alu_4_32_bits
PORT(
mux_in_0 : 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 function_class : std_logic_vector(1 downto 0) := (others => '0');
--Outputs
signal mux_out : std_logic_vector(31 downto 0);
BEGIN
uut: mux_alu_4_32_bits PORT MAP (
mux_in_0 => mux_in_0,
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";
24
ETyC2010
wait for 10 ns;

mux_in_0<="00000000000000000000000000000001";
--completar!!
mux_in_3<="00000000000000000000000000000100";
wait for 10 ns;
mux_in_0<="00000000000000000000000000000001";
--completar!!
mux_in_3<="00000000000000000000000000000100";
wait for 10 ns;
end Process;
END;
6.
Simulacin:
Fig.12Simulacindelmultiplexor4x1
25
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.
a)
If: instruccin de bifurcacin. Dependiendo de si la condicin es verdadera o falsa se ejecuta un

if CONDITION then
else
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
ETyC2010
4.
----------------------------------------------------------------------------library IEEE;
--library UNISIM;
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;
ENTITY se_main_tb IS
END se_main_tb;
ARCHITECTURE behavior OF se_main_tb IS
COMPONENT se_main
PORT(
se_in : IN std_logic_vector(15 downto 0);
se_out : OUT std_logic_vector(31 downto 0)
27
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
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
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
ETyC2010
3.
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.
----------------------------------------------------------------------------library IEEE;
30
ETyC2010

--library UNISIM;
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;
ENTITY fa_1_bit_tb IS
END fa_1_bit_tb;
ARCHITECTURE behavior OF fa_1_bit_tb 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;
--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
ETyC2010
BEGIN
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
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.
33
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
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.
---------------------------------------------------------------------------library IEEE;
--library UNISIM;
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
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
35
ETyC2010
yi =>y(31),
ci =>sig(30),
si =>s(31));
end Behavioral;
5.
Bancodeprueba:
---------------------------------------------------------------------------LIBRARY ieee;
ENTITY adder_alu_32_bits_tb IS
END adder_alu_32_bits_tb;
ARCHITECTURE behavior OF adder_alu_32_bits_tb IS
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
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
ETyC2010
END;
6.
Simulacin:
Fig.20Simulacindeunsumadortotalde32bits
37
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
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.
----------------------------------------------------------------------------library IEEE;
--library UNISIM;
entity alu is
Port ( x : in STD_LOGIC_VECTOR (31 downto 0);
constant_amount : in STD_LOGIC_VECTOR (4 downto 0);
constant_var : in STD_LOGIC;
logic_function : in STD_LOGIC_VECTOR (1 downto 0);
add_sub : in STD_LOGIC;
shift_function : in STD_LOGIC_VECTOR (1 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);
39
ETyC2010

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
ETyC2010
LIBRARY ieee;
ENTITY alu_tb_vhd IS
END alu_tb_vhd;
ARCHITECTURE behavior OF alu_tb_vhd IS
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;
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
uut: alu PORT MAP(
x => x,
y => y,
constant_amount => constant_amount,
constant_var => constant_var,
logic_function => logic_function,
add_sub => add_sub,
shift_function => shift_function,
s => s
);
41
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';
logic_function<="00";
add_sub<='0';
shift_function<="01";
wait for 10 ns;
end Process;
END;
6.
Simulacin:
Fig.22SimulacindeunaALU
42
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.
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
ETyC2010
if(clkevent AND clk =1)

if(clkevent AND clk =1)
--- flanco de subida

--- flanco de subida
4.
--------------------------------------------------------------------------library IEEE;
--library UNISIM;
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;
ENTITY pc_tb IS
END pc_tb;
ARCHITECTURE behavior OF pc_tb IS
44
ETyC2010

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);
constant clk_period : time := 1us;
BEGIN
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
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.
46
ETyC2010
---------------------------------------------------------------------------library IEEE;
--library UNISIM;
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 (
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
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;
ENTITY next_address_tb IS
END next_address_tb;
ARCHITECTURE behavior OF next_address_tb 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);
48
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
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
ETyC2010

empezo en 0
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
empezo en 0
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)
empezo en 0
na_PCSrc<="10";--salta registro
wait for 10 ns;
--Muestra a la salida el valor de syscalladdr
--Instruccion syscall para pedir uso del sistema
empezo en 0
na_PCSrc<="11";--Peticion del sistema syscall
wait for 10 ns;
end process;
END;
6.
Simulacin:
50
ETyC2010
Fig.26SimulaciondelbloqueNEXTADDRES
51
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;
--library UNISIM;
entity datapath is
Port ( clk_RegFile : in STD_LOGIC;
clk_PC : in STD_LOGIC;
BrType : in STD_LOGIC_VECTOR (1 downto 0);
RegDst : in STD_LOGIC_VECTOR (1 downto 0);
RegWrite : in STD_LOGIC;
52
ETyC2010
ALUSrc : in STD_LOGIC;
--constant_amount : in STD_LOGIC_VECTOR (4 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);

corrimiento a la izquierda
a la derecha
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);
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;

component mux_datapath_regfile
Port ( mux_in_0 : in 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
write_addr: in STD_LOGIC_VECTOR(4 downto 0);--direccion de escritura
data_in: in STD_LOGIC_VECTOR(31 downto 0);--Dato de entrada
direccion 1
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);--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;
end component;
component alu
Port ( x : in
54
ETyC2010

constant_amount : in STD_LOGIC_VECTOR (4 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);
end component;
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
signal
begin
sig0: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
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
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;
ENTITY datapath_tb IS
END datapath_tb;
57
ETyC2010
ARCHITECTURE behavior OF datapath_tb IS

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);
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_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
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);

constant clk_RegFile_period : time := 1us;
constant clk_PC_period : time := 1us;
BEGIN
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,
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
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
ETyC2010
3. Simulacin
Fig.28Simulacindelarutadedatossencilla
61
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
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
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
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
---------------------------------------------------------------------------------library IEEE;
--library UNISIM;
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
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
ETyC2010
LIBRARY ieee;
ENTITY deco_1_control_unit_tb IS
END deco_1_control_unit_tb;
ARCHITECTURE behavior OF deco_1_control_unit_tb 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;
--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
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_op_in<="000001";--op=1
wait for 10 ns;
deco_1_op_in<="000010";--op=2
wait for 10 ns;
67
ETyC2010
deco_1_op_in<="000011";--op=3
wait for 10 ns;
deco_1_op_in<="000100";--op=4
wait for 10 ns;
deco_1_op_in<="000101";--op=5
wait for 10 ns;
deco_1_op_in<="001000";--op=8
wait for 10 ns;
deco_1_op_in<="001010";--op=10
wait for 10 ns;
deco_1_op_in<="001100";--op=12
wait for 10 ns;
deco_1_op_in<="001101";--op=13
wait for 10 ns;
deco_1_op_in<="001110";--op=14
wait for 10 ns;
deco_1_op_in<="100011";--op=35
wait for 10 ns;
deco_1_op_in<="101011";--op=43
wait for 10 ns;
end Process;
END;
6. Simulacin
Fig.32SimulacindeIdecodificadordeinstrucciones1
68
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
---------------------------------------------------------------------------------library IEEE;
--library UNISIM;
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);
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
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;
70
ETyC2010
ENTITY deco_2_control_unit_tb IS
END deco_2_control_unit_tb;
ARCHITECTURE behavior OF deco_2_control_unit_tb IS
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
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_fn_in<="000000";--op=0
wait for 10 ns;
deco_2_fn_in<="000010";--op=2
wait for 10 ns;
deco_2_fn_in<="000011";--op=3
wait for 10 ns;
deco_2_fn_in<="000100";--op=4
wait for 10 ns;
deco_2_fn_in<="000110";--op=6
wait for 10 ns;
71
ETyC2010
deco_2_fn_in<="000111";--op=7
wait for 10 ns;
deco_2_fn_in<="001000";--op=8
wait for 10 ns;
deco_2_fn_in<="001100";--op=12
wait for 10 ns;
deco_2_fn_in<="100000";--op=32
wait for 10 ns;
deco_2_fn_in<="100010";--op=34
wait for 10 ns;
deco_2_fn_in<="100100";--op=36
wait for 10 ns;
deco_2_fn_in<="100101";--op=37
wait for 10 ns;
deco_2_fn_in<="100110";--op=38
wait for 10 ns;
deco_2_fn_in<="100111";--op=39
wait for 10 ns;
deco_2_fn_in<="101010";--op=42
wait for 10 ns;
end Process;
END;
6. Simulacin
Fig.33SimulacindeIdecodificadordeinstrucciones2
72
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;
--library UNISIM;
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
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
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;
ENTITY aux_signals_control_unit_tb IS
END aux_signals_control_unit_tb;
75
ETyC2010
ARCHITECTURE behavior OF aux_signals_control_unit_tb IS

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
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
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
--[13]
--[14]
--[15]
--[16]
--[17]
--[18]
--[19]
--[20]
--[21]
--[22]
--[23]
--[24]
--[25]
--[26]
--[27]

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
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
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
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;
--library UNISIM;
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);
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);
end component;
80
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
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
--[13]
--[14]
--[15]
--[16]
--[17]
--[18]
--[19]
--[20]
--[21]
--[22]
--[23]
--[24]
--[25]
--[26]
--[27]

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(7 downto 6) => bits_no_usados(1 downto 0),
deco_1_out(9) => bits_no_usados(2),
deco_1_out(63 downto 44) => bits_no_usados(49 downto 30)
);
deco_2_control_unit_1:deco_2_control_unit
PORT MAP (
82
ETyC2010
deco_2_enable_in =>sig0,
deco_2_fn_in => cu_fn_in,
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,
83
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;
ENTITY control_unit_tb IS
END control_unit_tb;
ARCHITECTURE behavior OF control_unit_tb IS
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
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
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
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
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
ETyC2010
DatapathyUnidaddeControl
1. CodigodelcomponenteenVHDL
---------------------------------------------------------------------------------library IEEE;
--library UNISIM;
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_op_out : out STD_LOGIC_VECTOR (5 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);
REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el
corrimiento a la derecha
88
ETyC2010
dp_cu_fn_out : out
end datapath_controlunit;
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;
BrType : in STD_LOGIC_VECTOR (1 downto 0);
RegWrite : in STD_LOGIC;
ALUSrc : in STD_LOGIC;
--constant_amount : in STD_LOGIC_VECTOR (4 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_pc
0);
0);
0);

89
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);
sig3: STD_LOGIC;
sig4: STD_LOGIC;
sig7: STD_LOGIC;
sig8: STD_LOGIC;
sig11: STD_LOGIC;
sig12: STD_LOGIC;
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
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_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
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;
ENTITY datapath_controlunit_tb IS
END datapath_controlunit_tb;
ARCHITECTURE behavior OF datapath_controlunit_tb 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_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
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);
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_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 dp_cu_fn_out : std_logic_vector(5 downto 0);
BEGIN
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_op_out => dp_cu_op_out,
test_alu_out => test_alu_out,
test_constant_amount => test_constant_amount,
93
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
ETyC2010
95
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;
--library UNISIM;
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_op_out : out STD_LOGIC_VECTOR (5 downto 0);
96
ETyC2010

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);
corrimiento a la derecha
dp_cu_fn_out : out
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
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
=
=
=
=
=
=
=
=
8
8
8
8
8
8
8
8
;
;
;
;
;
;
;
;

Curso ETyC Raul Peralta

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Curso ETyC Raul Peralta

Transféré par

Droits d'auteur :

Formats disponibles

ExposicinTecnolgicayCientfica

MSc. Ral Peralta Meza

Arquitectura del juego de instrucciones

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

Implementacin y simulacin de los

Implementacin: Para la implementacion se asume

(arquitectura) esta instruccin permite definir la funcin lgica que

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

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

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

when VALUE_1 =>

when VALUE_4 to VALUE_N =>

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

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

REG01 when read_addr_1 = "00001" else

wait for CLK_PERIOD * 2;

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

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

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

when VALUE_1 =>

when VALUE_2 | VALUE_3

wait for 10 ns;

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

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

Implementacin y simulacin de la ALU en

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

---- Uncomment the following library declaration if instantiating

architecture Behavioral of fa_1_bit is

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

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

la instruccin component se usa para declarar componentes dentro de

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

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

architecture structure of latch is

del sumador de 1 bit

La Unidad aritmtica lgica

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

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

InstruccionesausarenVHDL: No figuran nuevas instrucciones.

signal sig3:STD_LOGIC_VECTOR (4 downto 0);

std_logic_vector(31 downto 0);

Bloque de contador de programa (PC) y el

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

if(clkevent AND clk =1)

--- flanco de subida

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

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

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

na_BrType : IN std_logic_vector(1 downto 0);

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

Sntesis y simulacin de la ruta de datos.

--Muestreando el registro para ver los

STD_LOGIC_VECTOR (29 downto 0);

STD_LOGIC_VECTOR (3 downto 0);

STD_LOGIC_VECTOR(31 downto 0);

STD_LOGIC_VECTOR (31 downto 0);

y : in STD_LOGIC_VECTOR (31 downto 0);

sig0:STD_LOGIC_VECTOR (31 downto 0);

ARCHITECTURE behavior OF datapath_tb IS

test_alu_out : std_logic_vector(31 downto 0);

-- Clock period definitions

--logic_function <= "00";

Derivacin de las seales de control.