Curso ETyC Raul Peralta

ExposicinTecnolgicayCientfica ETyC2010

1 Tutorial:Implementaciondeunprocesadorderutadedatossencilla

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



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.



Contenido

Arquitecturadeljuegodeinstrucciones.............................................................................................9

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

Implementacinysimulacindelosbloquesarchivoderegistro,multiplexoresyextensindesignoenVHDL...................................................................................................................................15

ARCHIVODEREGISTROS...............................................................................................................151. Definicin:.....................................................................................................................152. Implementacin:...........................................................................................................153. InstruccionesausarenVHDL:.......................................................................................164. CdigodelcomponenteenVHDL.................................................................................175. Bancodeprueba...........................................................................................................196. Simulacin:....................................................................................................................21

MULTIPLEXOR................................................................................................................................221. Definicin:.....................................................................................................................222. Implementacin:...........................................................................................................223. InstruccionesausarenVHDL:.......................................................................................224. CdigodelComponenteenVHDL:................................................................................235. Bancodepruebas:.........................................................................................................236. Simulacin:....................................................................................................................25

EXTENSINDESIGNO...................................................................................................................261. Definicin:.....................................................................................................................262. Implementacin:...........................................................................................................263. InstruccionesausarenVHDL:.......................................................................................264. CdigodelcomponenteenVHDL:................................................................................275. Bancodepruebas:.........................................................................................................276. Simulacin:....................................................................................................................28



ImplementacinysimulacindelaALUenVHDL............................................................................29

SUMADORTOTALDEUNBIT.........................................................................................................291. Definicin:.....................................................................................................................292. Implementacin:...........................................................................................................293. InstruccionesausarenVHDL:.......................................................................................304. CdigodelcomponenteenVHDL:................................................................................305. Bancodeprueba:..........................................................................................................316. Simulacin:....................................................................................................................32

SUMADORTOTALDE32BITS........................................................................................................331. Definicin:.....................................................................................................................332. Implementacin:...........................................................................................................333. InstruccionesausarenVHDL:.......................................................................................334. CdigodelcomponenteenVHDL:................................................................................355. Bancodeprueba:..........................................................................................................366. Simulacin:....................................................................................................................37

LaUnidadaritmticalgica...............................................................................................................38

ImplementacindelaALU............................................................................................................381. Definicin:.....................................................................................................................382. Implementacin:...........................................................................................................383. InstruccionesausarenVHDL:.......................................................................................394. CdigodelcomponenteenVHDL:................................................................................395. Bancodeprueba:..........................................................................................................406. Simulacin:....................................................................................................................42

Bloquedecontadordeprograma(PC)yelbloquequecalculalasiguientedireccin(NEXTADDRESS)..........................................................................................................................................43

PC(Contadordeprograma)..........................................................................................................431. Definicin:.....................................................................................................................432. Implementacin:...........................................................................................................433. InstruccionesausarenVHDL:.......................................................................................434. CdigodelcomponenteenVHDL:................................................................................445. Bancodeprueba:..........................................................................................................446. Simulacin:....................................................................................................................45

NEXTADDRESS(siguientedireccin)............................................................................................46



1. Definicin:.....................................................................................................................462. Implementacin:...........................................................................................................463. InstruccionesausarenVHDL:.......................................................................................464. CdigodelcomponenteenVHDL:................................................................................465. Bancodeprueba:..........................................................................................................486. Simulacin:....................................................................................................................50

Sntesisysimulacindelarutadedatos..........................................................................................52

Introduccin..................................................................................................................................521. CdigodelcomponenteenVHDL:................................................................................522. Bancodeprueba:..........................................................................................................573. Simulacin.....................................................................................................................61

Derivacindelassealesdecontrol.................................................................................................62

ImplementacinysimulacinenVHDLdelaunidaddecontrol.Bloques:decodificadores,circuitoscombinacionales................................................................................................................................62

DecodificadordeInstrucciones1..................................................................................................651. Definicin:.....................................................................................................................652. Implementacin:...........................................................................................................653. InstruccionesausarenVHDL:.......................................................................................654. CdigodelcomponenteenVHDL:................................................................................655. Bancodeprueba:..........................................................................................................666. Simulacin.....................................................................................................................68

DecodificadordeInstrucciones2..................................................................................................691. Definicin:.....................................................................................................................692. Implementacin:...........................................................................................................693. InstruccionesausarenVHDL:.......................................................................................694. CdigodelcomponenteenVHDL:................................................................................695. Bancodepruebas..........................................................................................................706. Simulacin.....................................................................................................................721. Definicion:.....................................................................................................................732.CdigodelcomponenteenVHDL.........................................................................................733. Bancodeprueba...........................................................................................................754. Simulacion.....................................................................................................................79



CONTROLUNIT..............................................................................................................................801. Definicin:.....................................................................................................................802. CdigoenVHDLdelcomponente.................................................................................803. Bancodeprueba...........................................................................................................84

DatapathyUnidaddeControl......................................................................................................881. CodigodelcomponenteenVHDL.................................................................................882. Bancodepruebas..........................................................................................................923. Simulacion.....................................................................................................................94

Procesador....................................................................................................................................96UserConstraintsFile.....................................................................................................................98



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



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



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



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:



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

Instruccionestipo 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



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:



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.



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:rutadedatossencillayunidaddecontrolLa 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.



Implementacin y simulacin de los bloques archivo de registro, multiplexores y extensin de signo en VHDL ARCHIVODEREGISTROS

1. Definicin: 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.

2. Implementacin: Para la implementacion se asume 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.



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



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

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

if CONDITION then -- sequential statements else -- sequential statements end if;

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

case EXPRESSION is when VALUE_1 => -- sequential statements when VALUE_2 | VALUE_3 => -- | = OR -- sequential statements when VALUE_4 to VALUE_N => -- to = range -- sequential statements when others => -- sequential statements end case ;

4. CdigodelcomponenteenVHDL:

---------------------------------------------------------------------------------- library IEEE; use IEEE.STD_LOGIC_1164.ALL; use IEEE.STD_LOGIC_ARITH.ALL; use IEEE.STD_LOGIC_UNSIGNED.ALL; ---- Uncomment the following library declaration if instantiating ---- any Xilinx primitives in this code. --library UNISIM; --use UNISIM.VComponents.all; entity 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



read_addr_2: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 2 write_addr: in STD_LOGIC_VECTOR(4 downto 0);--direccion de escritura data_in: in STD_LOGIC_VECTOR(31 downto 0);--Dato de entrada data_out_1: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la direccion 1 data_out_2: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la direccion 2 --Muestreando el registro para ver los valores de fibonacci REG_T0: out STD_LOGIC_VECTOR(31 downto 0);--previos de la serie de fibnacci REG_T1: out STD_LOGIC_VECTOR(31 downto 0);--previos de la serie de fibnacci REG_T3: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere la serie de fibonacci REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el corrimiento a la izquierda REG_T5: out STD_LOGIC_VECTOR(31 downto 0)--aqui vere el corrimiento a la derecha ); end reg_file_32_bits; architecture Behavioral of reg_file_32_bits is -- INTERNAL REGISTERS. signal REG00: STD_LOGIC_VECTOR(31 downto 0):=x"00000000"; signal REG01: STD_LOGIC_VECTOR(31 downto 0):=x"00000000"; --completar!! signal REG31: STD_LOGIC_VECTOR(31 downto 0):=x"00000000"; begin REG_T0



REG01 when read_addr_1 = "00001" else --completar!! REG31 when read_addr_1 = "11111" else REG00; -- read_addr_2 data_out_2 '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');



--Outputs signal data_out_1 : std_logic_vector(31 downto 0); signal data_out_2 : std_logic_vector(31 downto 0); signal REG_T0 : std_logic_vector(31 downto 0); signal REG_T1 : std_logic_vector(31 downto 0); signal REG_T3 : std_logic_vector(31 downto 0); signal REG_T4 : std_logic_vector(31 downto 0); signal REG_T5 : std_logic_vector(31 downto 0); -- Clock period definitions constant clk_period : time := 1ns; BEGIN -- Instantiate the Unit Under Test (UUT) uut: reg_file_32_bits PORT MAP ( write_enable => write_enable, clk => clk, read_addr_1 => read_addr_1, read_addr_2 => read_addr_2, write_addr => write_addr, data_in => data_in, data_out_1 => data_out_1, data_out_2 => data_out_2, REG_T0 => REG_T0, REG_T1 => REG_T1, REG_T3 => REG_T3, REG_T4 => REG_T4, REG_T5 => REG_T5 ); Escritura : Process Begin write_enable



wait for CLK_PERIOD * 2; write_addr



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.


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


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

case EXPRESSION is when VALUE_1 => -- sequential statements when VALUE_2 | VALUE_3 => -- | = OR -- sequential statements when VALUE_4 to VALUE_N => -- to = range



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

4. CdigodelComponenteenVHDL:

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

-- completar!!! when others => mux_out



USE ieee.std_logic_unsigned.all; USE ieee.numeric_std.ALL; ENTITY mux_alu_4_32_bits_tb IS END mux_alu_4_32_bits_tb; ARCHITECTURE behavior OF mux_alu_4_32_bits_tb IS -- Component Declaration for the Unit Under Test (UUT) COMPONENT mux_alu_4_32_bits PORT( mux_in_0 : IN std_logic_vector(31 downto 0); mux_in_1 : IN std_logic_vector(31 downto 0); mux_in_2 : IN std_logic_vector(31 downto 0); mux_in_3 : IN std_logic_vector(31 downto 0); function_class : IN std_logic_vector(1 downto 0); mux_out : OUT std_logic_vector(31 downto 0) ); END COMPONENT; --Inputs signal mux_in_0 : std_logic_vector(31 downto 0) := (others => '0'); signal mux_in_1 : std_logic_vector(31 downto 0) := (others => '0'); signal mux_in_2 : std_logic_vector(31 downto 0) := (others => '0'); signal mux_in_3 : std_logic_vector(31 downto 0) := (others => '0'); signal function_class : std_logic_vector(1 downto 0) := (others => '0'); --Outputs signal mux_out : std_logic_vector(31 downto 0); BEGIN -- Instantiate the Unit Under Test (UUT) uut: mux_alu_4_32_bits PORT MAP ( mux_in_0 => mux_in_0, mux_in_1 => mux_in_1, mux_in_2 => mux_in_2, mux_in_3 => mux_in_3, function_class => function_class, mux_out => mux_out ); Mux_alu: Process begin mux_in_0



wait for 10 ns; mux_in_0



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.


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


b) &:instruccin para unir o concatenr bits. La concatenacin solo se permite en la parte derecha de una operacin de asignacin




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



); END COMPONENT; --Inputs signal se_in : std_logic_vector(15 downto 0) := (others => '0'); --Outputs signal se_out : std_logic_vector(31 downto 0); BEGIN -- Instantiate the Unit Under Test (UUT) uut: se_main PORT MAP ( se_in => se_in, se_out => se_out ); SE: Process begin se_in



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




a)



---- Uncomment the following library declaration if instantiating ---- any Xilinx primitives in this code. --library UNISIM; --use UNISIM.VComponents.all; entity fa_1_bit is Port ( xi : in STD_LOGIC;--entrada de 1 bit yi : in STD_LOGIC;--entrada de 1 bit ci : in STD_LOGIC;--acarreo de entrada si : out STD_LOGIC;--suma de xi y yi co : out STD_LOGIC);--acarrei de salida end fa_1_bit; architecture Behavioral of fa_1_bit is begin si



BEGIN -- Instantiate the Unit Under Test (UUT) uut: fa_1_bit PORT MAP ( xi => xi, yi => yi, ci => ci, si => si, co => co ); xi_signal: Process begin xi



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.




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) portmap: 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);



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;


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

yi =>y(1), ci =>sig(0), si =>s(1), co =>sig(1));

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



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

5. Bancodeprueba:

---------------------------------------------------------------------------- LIBRARY ieee; USE ieee.std_logic_1164.ALL; USE ieee.std_logic_unsigned.all; USE ieee.numeric_std.ALL; ENTITY adder_alu_32_bits_tb IS END adder_alu_32_bits_tb; ARCHITECTURE behavior OF adder_alu_32_bits_tb IS -- Component Declaration for the Unit Under Test (UUT) COMPONENT adder_alu_32_bits PORT( x : IN std_logic_vector(31 downto 0); y : IN std_logic_vector(31 downto 0); cin : IN std_logic; s : OUT std_logic_vector(31 downto 0) ); END COMPONENT; --Inputs signal x : std_logic_vector(31 downto 0) := (others => '0'); signal y : std_logic_vector(31 downto 0) := (others => '0'); signal cin : std_logic := '0'; --Outputs signal s : std_logic_vector(31 downto 0); BEGIN -- Instantiate the Unit Under Test (UUT) uut: adder_alu_32_bits PORT MAP ( x => x, y => y, cin => cin, s => s ); adder: Process begin

--completar con un par de sumas!! end Process;



END;

6. Simulacin:

Fig.20Simulacindeunsumadortotalde32bits



La Unidad aritmtica lgica ImplementacindelaALU

1. Definicin: 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.

2. Implementacin: Para la implementacin se ha empleado el diagrama que se muestra en la 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



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. InstruccionesausarenVHDL: No figuran nuevas instrucciones.


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



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

5. Bancodeprueba:

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



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



ALU_test:Process Begin x



Bloque de contador de programa (PC) y el bloque que calcula la siguiente direccin (NEXT ADDRESS). PC(Contadordeprograma)

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

Fig.23Digramadebloquedeuncontadordeprograma(PC)

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

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

3. InstruccionesausarenVHDL: a) event: esta no es una instruccin sino que es un atributo que puede ser asociado a datos en

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



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


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



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



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




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



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



na_BrType : IN std_logic_vector(1 downto 0); na_PCSrc : IN std_logic_vector(1 downto 0); na_NextPC : OUT std_logic_vector(29 downto 0); na_IncrPC : OUT std_logic_vector(29 downto 0) ); END COMPONENT; --Inputs signal na_rt : std_logic_vector(31 downto 0) := (others => '0'); signal na_rs : std_logic_vector(31 downto 0) := (others => '0'); signal na_PC_31_2 : std_logic_vector(29 downto 0) := (others => '0'); signal na_jta : std_logic_vector(25 downto 0) := (others => '0'); signal na_syscalladdr : std_logic_vector(29 downto 0) := (others => '0'); signal na_BrType : std_logic_vector(1 downto 0) := (others => '0'); signal na_PCSrc : std_logic_vector(1 downto 0) := (others => '0'); --Outputs signal na_NextPC : std_logic_vector(29 downto 0); signal na_IncrPC : std_logic_vector(29 downto 0); BEGIN -- Instantiate the Unit Under Test (UUT) uut: next_address PORT MAP ( na_rt => na_rt, na_rs => na_rs, na_PC_31_2 => na_PC_31_2, na_jta => na_jta, na_syscalladdr => na_syscalladdr, na_BrType => na_BrType, na_PCSrc => na_PCSrc, na_NextPC => na_NextPC, na_IncrPC => na_IncrPC ); Next_address_test:Process begin --PC_31_2(PC actual) + 1 --Para instrucciones tipo R, operaciones logicas, carga y almacenaje en memoria na_rt



na_rt



Fig.26SimulaciondelbloqueNEXTADDRES



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

Fig.27Rutadedatosdeciclosencilla

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



ALUSrc : in STD_LOGIC; add_sub : in STD_LOGIC; logic_function : in STD_LOGIC_VECTOR (1 downto 0); function_class : in STD_LOGIC_VECTOR (1 downto 0); --constant_amount : in STD_LOGIC_VECTOR (4 downto 0); constant_var : in STD_LOGIC; shift_function : in STD_LOGIC_VECTOR (1 downto 0); DataRead : in STD_LOGIC; DataWrite : in STD_LOGIC; RegInSrc : in STD_LOGIC_VECTOR (1 downto 0); op : out STD_LOGIC_VECTOR (5 downto 0); fn : out STD_LOGIC_VECTOR (5 downto 0); --verificando salida de la alu test_alu_out:out STD_LOGIC_VECTOR(31 downto 0); test_constant_amount:out STD_LOGIC_VECTOR (4 downto 0); test_y_alu:out STD_LOGIC_VECTOR(31 downto 0); test_rs:out STD_LOGIC_VECTOR(31 downto 0); test_rt:out STD_LOGIC_VECTOR(31 downto 0); test_im:out STD_LOGIC_VECTOR(31 downto 0); --test de PC test_Pc_in:out STD_LOGIC_VECTOR(29 downto 0); test_Pc_out:out STD_LOGIC_VECTOR(29 downto 0); test_instruc_out: out STD_LOGIC_VECTOR(31 downto 0); --Muestreando el registro para ver los valores de fibonacci REG_T0: out STD_LOGIC_VECTOR(31 downto 0); REG_T1: out STD_LOGIC_VECTOR(31 downto 0); REG_T3: out STD_LOGIC_VECTOR(31 downto 0); REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el corrimiento a la izquierda REG_T5: out STD_LOGIC_VECTOR(31 downto 0)--aqui vere el corrimiento a la derecha ); 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 STD_LOGIC_VECTOR (29 downto 0);



clk : in STD_LOGIC; pc_out : out STD_LOGIC_VECTOR (29 downto 0)); end component; component instr_cache Port ( instr_cache_addr : in STD_LOGIC_VECTOR (3 downto 0); instr_cache_out : out STD_LOGIC_VECTOR (31 downto 0)); end component; component mux_datapath_regfile Port ( mux_in_0 : in STD_LOGIC_VECTOR (4 downto 0); mux_in_1 : in STD_LOGIC_VECTOR (4 downto 0); mux_in_2 : in STD_LOGIC_VECTOR (4 downto 0); RegDst : in STD_LOGIC_VECTOR (1 downto 0); mux_out : out STD_LOGIC_VECTOR (4 downto 0)); end component; component reg_file_32_bits port ( write_enable: in STD_LOGIC;--Activar la escritura del registro clk: in STD_LOGIC;--Clock --read_enable: in STD_LOGIC;--Activar la lectura del registro read_addr_1: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 1 read_addr_2: in STD_LOGIC_VECTOR(4 downto 0);--direccion de lectura 2 write_addr: in STD_LOGIC_VECTOR(4 downto 0);--direccion de escritura data_in: in STD_LOGIC_VECTOR(31 downto 0);--Dato de entrada data_out_1: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la direccion 1 data_out_2: out STD_LOGIC_VECTOR(31 downto 0);--salida de la lectura del dato de la direccion 2 REG_T0: out STD_LOGIC_VECTOR(31 downto 0); REG_T1: out STD_LOGIC_VECTOR(31 downto 0); REG_T3: out STD_LOGIC_VECTOR(31 downto 0); REG_T4: out STD_LOGIC_VECTOR(31 downto 0);--aqui vere el corrimiento a la izquierda REG_T5: out STD_LOGIC_VECTOR(31 downto 0)--aqui vere el corrimiento a la derecha ); end component; component se_main Port ( se_in : in STD_LOGIC_VECTOR (15 downto 0); se_out : out STD_LOGIC_VECTOR (31 downto 0)); end component; component mux_datapath_alu Port ( mux_rt_in : in STD_LOGIC_VECTOR (31 downto 0); mux_se_in : in STD_LOGIC_VECTOR (31 downto 0); ALUSrc:in STD_LOGIC; mux_out : out STD_LOGIC_VECTOR (31 downto 0)); end component; component alu Port ( x : in STD_LOGIC_VECTOR (31 downto 0);



y : in STD_LOGIC_VECTOR (31 downto 0); constant_amount : in STD_LOGIC_VECTOR (4 downto 0); constant_var : in STD_LOGIC; function_class : in STD_LOGIC_VECTOR (1 downto 0); logic_function : in STD_LOGIC_VECTOR (1 downto 0); add_sub : in STD_LOGIC; shift_function : in STD_LOGIC_VECTOR (1 downto 0); s : out STD_LOGIC_VECTOR (31 downto 0)); end component; component data_cache Port ( data_cache_address : in STD_LOGIC_VECTOR (3 downto 0); data_in : in STD_LOGIC_VECTOR (31 downto 0); data_read : in STD_LOGIC; data_write : in STD_LOGIC; data_out : out STD_LOGIC_VECTOR (31 downto 0)); end component; component mux_datapath_datacache Port ( mux_datacache_in : in STD_LOGIC_VECTOR (31 downto 0); mux_alu_in : in STD_LOGIC_VECTOR (31 downto 0); mux_incrPC_in : in STD_LOGIC_VECTOR (31 downto 0); RegIncr : in STD_LOGIC_VECTOR (1 downto 0); mux_out : out STD_LOGIC_VECTOR (31 downto 0)); end component; signal sig0:STD_LOGIC_VECTOR (31 downto 0); signal sig1:STD_LOGIC_VECTOR (31 downto 0); signal sig2:STD_LOGIC_VECTOR (29 downto 0); signal sig3:STD_LOGIC_VECTOR (31 downto 0); signal sig4:STD_LOGIC_VECTOR (29 downto 0); signal sig5:STD_LOGIC_VECTOR (29 downto 0); signal sig6:STD_LOGIC_VECTOR (4 downto 0); signal sig7:STD_LOGIC_VECTOR (31 downto 0); signal sig8:STD_LOGIC_VECTOR (31 downto 0); signal sig9:STD_LOGIC_VECTOR (31 downto 0); signal sig10:STD_LOGIC_VECTOR (31 downto 0); signal sig11:STD_LOGIC_VECTOR (31 downto 0); signal sig12:STD_LOGIC_VECTOR (31 downto 0); begin 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,



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(



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



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



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 REG_T0 : std_logic_vector(31 downto 0); signal REG_T1 : std_logic_vector(31 downto 0); signal REG_T3 : std_logic_vector(31 downto 0); -- Clock period definitions constant clk_RegFile_period : time := 1us; constant clk_PC_period : time := 1us; BEGIN -- Instantiate the Unit Under Test (UUT) uut: datapath PORT MAP ( clk_RegFile => clk_RegFile, clk_PC => clk_PC, PCSrc => PCSrc, BrType => BrType, RegDst => RegDst, RegWrite => RegWrite, ALUSrc => ALUSrc, add_sub => add_sub, logic_function => logic_function, function_class => function_class, constant_var => constant_var, shift_function => shift_function, DataRead => DataRead, DataWrite => DataWrite, RegInSrc => RegInSrc, op => op, fn => fn, test_alu_out => test_alu_out, test_constant_amount => test_constant_amount, test_y_alu => test_y_alu, test_rs => test_rs, test_rt => test_rt, test_im => test_im, REG_T0 => REG_T0, REG_T1 => REG_T1, REG_T3 => REG_T3 ); Datapath_test:Process begin --clk_RegFile



--logic_function



3. Simulacin

Fig.28Simulacindelarutadedatossencilla



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:



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.



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



DecodificadordeInstrucciones1

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

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

3. InstruccionesausarenVHDL:No aplica

4. CdigodelcomponenteenVHDL:-----------------------------------------------------------------

Documents

Curso ETyC Raul Peralta