Reporte Arqui

Introduccin
Se disear una implementacin que incluya las instrucciones ms

importantes. Instrucciones de acceso a memoria: lw, sw Instrucciones
aritmtico-lgicas: add, sub, slt, and, or
Brincos: BEQ, J
Pasos generales
Enviar el contador del programa (PC) a la memoria que contiene el cdigo y
atrapar la instruccin.Leer uno o dos registros usando los campos de la
instruccin para seleccionar los registros a leer.Uso de la ALU para el clculo
de una direccin, ejecucin de una operacin aritmtica o lgica o
comparaciones.
Acceso a la memoria de datos para lectura o escritura
DLXMICROPROCESADOR(DATAPATH 3) Noviembre/2006/6
Datapath (camino de datos)

Formato de instruccin R
Las instrucciones aritmticas registro a registro, utilizan el formato de
instruccin tipo R
Op: Es el cdigo de instruccin

Funct: Es el que le va a indicar al control de la ALU qu operacin aritmtica
har.
rs: Es donde se guardar el primer registro fuente.
rd: Es donde se guardar el segundo registro fuente.
rt: Es la direccin destino, es decir, donde sern guardados los registros.
Formato de instruccin Tipo l
rs: Es donde se guardar el primer registro fuente.

rt: Es donde se guardar el segundo registro fuente.
Offset: Tendr lo que es el desplazamiento, no tendr ni el shamt ni el funct.
Formato de instruccin en J(salta incondicional)
4 Direccion
____________________________
6 26
esta instruccin slo contiene el cdigo de operacin y la direccin a donde
va a saltar
Ahora especificaremos cmo funcionan cada una de las partes del datapath.
para el diseo del control principal debemos recordar lo siguiente:
Bits 31-26: opcode - Instrucciones

Bits 25-21 y 20-16: ndices de registro de entrada, siempre en esta
ubicacin. Aqu es donde entran los dos datos o registros para hacer las
operaciones en las tipo R o comparaciones.
base para instrucciones de carga / almacenamiento, siempre en esta ubicacin
Bits 15-0: desplazamiento de 16 bits para la instruccin de bifurcacin,
siempre en esta ubicacin
Bits 15-11: registro de destino para instrucciones de formato R - siempre en
esta ubicacin
Bits 20-16: registro de destino para instrucciones de carga / almacenamiento,
siempre en esta ubicacin
Ahora explicaremos como funcionan algunos los multiplexores:
RegDst
Desactivado: el nmero de destino de registro para el registro de escritura se
toma de los bits 20-16 (campo rt) de la instruccin
Activado: el nmero de destino de registro para el registro de Escritura se
toma de los bits 15-11 (campo rd) de la instruccin
____________________________
ALUSrc
Desactivado: el segundo operando de ALU se toma de la salida del segundo
archivo de registro (ReadData 2). Es decir, solo se activa con las
instrucciones tipo R ya que el Read Data 2 para por el 0 del mux haciendo
que lo que salga del read data 2, pase directamente.
Activado: el segundo operando alu es el signo extendido, 16 bits ms bajos de
la instruccin. Este mux est en 1 cuando se ocupan las instrucciones tipo
R, Ya que el primer registro de las instrucciones tipo R entra por el Read
Data 1, y el segundo pasa por el signo extendido, haciendo que entre active el
mux.
PCSrc
Desactivado: la PC sobrescribe la salida del sumador (PC + 1), es decir, el
contador suma 1 cada ciclo del reloj.
Activado: PC sobrescrito por la direccin de destino. Cuando existe un salto,
este mux se activa haciendo que se sume lo que tiene el signo extendido con
lo que tiene el PC, haciendo que se vuelva a actualizar en el siguiente ciclo.
MemRead
Desactivado: ninguna accin
Activado:Este acceso se ocupa solamente cuando se guardaran elementos, es
decir con la instruccin Sw, lo que har es guardar lo que tenga el Read
Data 2 en la Memoria Read, no pasara por otra instruccin.
MemWrite
Desactivado: ninguna accin
Activado: Los contenidos de la memoria de datos designados por la entrada
de direccin estn presentes en la entrada WriteData
RegWrite
____________________________
Desactivado: el valor presente en la entrada WriteData se enva desde la

ALU, no pasa por otro valor, directamente se va a la Alu.
Activado: el valor presente en la entrada WriteData del registro se toma de la
memoria de datos
MemtoWrite
Desactivado: Este mux est desactivado cuando la instruccin no ocupa
ninguna direccin, por lo tanto cuando sale de Alu result sigue el camino
para pasar por el bit 0 del mux,y despus ir al write data.
Activado: Este mux se activa cuando, ocupamos la instruccin tipo Lw, Lo
que hace hace es que, sale de la Alu result, entra por una direccin y sale
por el Read Data, haciendo que active el mux para posteriormente ir al write
data.
ALUOp
Este control se ocupa para saber qu instruccin va a realizar. Por eso
contiene los bits 5-0 para identificar el tipo de instruccin y con ello saber
qu es lo que va a realizar.
La unidad de control puede establecer todas las seales de control, excepto
una que es la PC Src. La cual solo se ocupa cuando las instrucciones son de
salto (beq o bne) y La salida de la alu es cero, o se enciende la bandera zero
del ALU , siempre y cuando la comparacin sea verdadera.
Un datapath es una coleccin de unidades funcionales tales como unidades

lgicas aritmticas o multiplicadores, que realizan operaciones de
procesamiento de datos, registros y buses. Junto con la unidad de control,
compone la unidad de procesamiento central (CPU).
____________________________
PC: Es un registro del procesador de un computador que indica la posicin

donde est el procesador en su secuencia de instrucciones. En cada flanco de
subida se actualiza el contador.
Ciclo de reloj: Este ciclo de reloj est conectado al PC, a la memoria de
instrucciones, al sumador y por ltimo a la RAM. Se necesita para que dichas
unidades vayan ms lentas que el banco de registros el cual tambin est
conectado al ciclo de reloj pero a un tiempo ms corto.
Memoria de instrucciones: Almacena las instrucciones a ejecutar.
Sumador: Se utilizar para calcular la direccin de la siguiente instruccin,
por medio del cual se sumar 1 al registro del contador del programa (este
elemento ms simple que una ALU, puesto que solo realiza la operacin de la
suma) por lo que se conecta al bus de direcciones de la memoria de
instrucciones.
Banco de registros: Esta estructura contiene una coleccin de registros en la

que cualquier registro puede ser ledo o escrito especificando el nmero de
registro en el archivo. Se necesita de una ALU que opere sobre los datos
ledos desde el registro.
En las instrucciones tipo R tiene tres operandos, por lo tanto, el banco de
registros lee los nmeros de los dos registros (rs y rt) y el nmero del registro
a escribir (rd), as como el dato que se escribir en el registro especificado.
La lectura de cada uno de ellos se realizar en cada flanco de reloj, pero la
____________________________
escritura solo se realiza en algunas instrucciones, por lo cual se debe incluir

una entrada de control que habilite la escritura de un dato en un registro.
Los datos obtenidos del banco de registros se conectan a la ALU y el
resultado se va a Write data.
Las instrucciones de carga y almacenamiento nos permiten la transferencia

las transferencias de memoria a registros o de registros a memoria. Para saber
cul es la direccin del dato en memoria, sumamos el contenido del registro
base con el desplazamiento (16 bits).
____________________________
Para este tipo de instrucciones necesitamos de otros elementos como: la

memoria de datos (RAM), la cual permite lectura (para cargas) y escritura
(para almacenamiento) y un mdulo de extensin de signo que en su entrada
tendr una palabra de 16 bits y la extender e signo para completar una
palabra de 32 bits.
La extensin de signo es necesaria porque la constante incluida en la
instruccin se presenta en complemento a 2, para poder acceder a los datos en
direcciones posteriores o anteriores al registro base; y puesto que la ALU es
de 32 bits, los dos operandos debern tener ese tamao.
La RAM es un elemento de estado y la unidad de extensin de signo es un
circuito combinacional.
Hay dos seales de control en la RAM las cuales se activan dependiendo del
tipo de instruccin que se est ejecutando.
Para construir el camino de datos requerido para las instrucciones de acceso a
memoria combinan los elementos los elementos de la imagen anterior con la
ALU y banco de registros. Se supone que la instruccin ya ha sido atrapada y
se encuentra presente en el bus de la entrada. La instruccin incluye al
registro base, cuyo contenido se toma del banco de registros, y al
desplazamiento que se extender en signo para sumarse al registro base; el
resultado de la suma corresponde a la direccin de la palabra a la cual se
acceder en memoria. En el caso de una carga, se tomar la palabra de la
memoria y se colocar en la entrada de datos del archivo de registros; pero si
se trata de un almacenamiento, el dato ledo del archivo de registros deber
escribirse en memoria.
La instruccin condicional en este caso beq tiene tres operandos: los dos
registros que se van a comparar para ver si son iguales y una constante de 16
bits utilizada como desplazamiento para hacer brincos relativos al sumador.
Adems de calcular la direccin destino del brinco, se debe determinar cul
ser la siguiente instruccin por ejecutarse, de acuerdo a la igualdad o
____________________________
desigualdad entre los registros. Si los contenidos de los registros son iguales
el brinco debe realizarse, por lo que el sumador deber ser sustituido por la
direccin calculada. Pero si no son iguales, el brinco no se realizar por lo
que se continuar con la instruccin ubicada en la direccin siguiente a la
direccin del brinco.
Por lo tanto, el camino de datos debe realizar las dos operaciones: calcular la
direccin destino del brinco y comparar los contenidos de los registros. La
ALU realizara una resta para verificar si los contenidos de los registros son
iguales de manera que el salto queda condicionado cuando la bandera zero
est en alto (es decir 1). Con otro sumador se obtendr la direccin destino
del brinco. En la instruccin se incluye al desplazamiento en 16 bits, ste se
extiende en signo y PC + 1. El resultado de la suma es la direccin destino
del brinco.
En el caso de la instruccin j, el salto es incondicional; es decir, no est
sujeto al resultado de una comparacin. La instruccin j tiene dos campos, un
campo de 6 bits que corresponde al opcode y otro de 26 bits que indica la
direccin destino del salto. Para esta instruccin tambin deber considerarse
que las instrucciones ocupan 4 bytes, El nuevo valor del contador de
instrucciones se obtendr concatenando los 6 bits menos.
En las imgenes anteriores se mostr el camino de datos para cada
instruccin, ahora se combinar para tener un solo camino de datos.
Debe tomarse en cuenta que se trata de una implementacin que ejecutar
todas las instrucciones en 1 ciclo de reloj. Esto significa que los recursos en
el camino de los datos no pueden ser usados ms de una vez por instruccin,
de manera que cualquier elemento que se requiera ms de una vez, deber ser
duplicado.
Al compartir elementos, pueden requerirse mltiples conexiones a una
entrada. Para ello se utilizarn multiplexores, y ser el control el que
determine cul de los datos fluir a cada entrada.
____________________________
Las instrucciones tipo R y de acceso a memoria utilizan a la ALU y el primer

operando en ambos casos es el dato escrito en el registro 1, obtenido del
archivo de registros, sin embargo, el segundo operando difiere para las dos
instrucciones: En el caso de las instrucciones tipo-R el segundo operando es
el dato escrito en el registro 2, obtenido del archivo de registros. mientras
que, para los accesos a memoria, el segundo operando es una constante
extendida en signo. Por lo que es necesario un multiplexor en la entrada del
segundo operando de la ALU. Las instrucciones tipo-R escriben el resultado
en un registro y en el caso de las cargas, se obtiene un dato de memoria para
ser escrito en un registro. Entonces, en la entrada de datos del archivo de
registros tambin deber colocarse un multiplexor por medio del cual se haga
esta seleccin. En el caso de los almacenamientos, este multiplexor no es
importante porque no hacen escritura en registro.
La parte de bsqueda y captura de la instruccin puede fcilmente agregarse,
se necesita la presencia de las dos memorias, la memoria de instrucciones y la
memoria de datos. Este camino de los datos requiere de un sumador adems
de la ALU, esto porque simultneamente la ALU realizar la operacin sobre
los datos, mientras que el sumador obtendr la direccin de la siguiente
instruccin a ejecutar.
Para completar el camino de los datos, debemos agregar la parte necesaria
para los brincos. Al agregar estos elementos, ser necesario el uso de un
multiplexor a la entrada del PC, para poder seleccionar entre PC + 1 y el
resultado de haber sumado a PC + 1 una constante. El camino de los datos
obtenido hasta el momento es el siguiente en cual puede ejecutar
instrucciones tipo-R, cargas, almacenamientos y brincos sobre igual.
____________________________
Control de la ALU
La seleccin entre cada una de las entradas depender de la clase de
instruccin. para cargas y almacenamientos se requiere que la ALU realice
una suma para calcular la direccin de la localidad de memoria a la que se
realizar el acceso. para instrucciones aritmtico lgicas la ALU realizara una
suma, resta,AND, OR, o ajuste sobre menor que, dependiendo del campo de
funcin que se encuentra en los 6 bits menos significativos en esta clase de
instrucciones.
como un primer paso realizaremos una pequea unidad de control que tenga
una entrada de 2 bits a la que se determin como ALUop. con esa entrada se
determina si la ALU realizara una suma para carga de almacenamientos, una
resta para brincos o si la operacin quedar determinada por el campo de la
funcin para instrucciones tipo R.la salida de la ALU se conectar
directamente con las lneas de control de la ALU.
____________________________
Teniendo el control ALU, es posible realizar el control principal. El control

bsicamente es un circuito lgico combinacional cuyas entradas
corresponden a los bits del opcode y sus salidas son las seales de control
ms las seales que requiere el control de la ALU.
____________________________
____________________________
DLXMICROPROCESADOR(DATAPATH 3)
Noviembre/2006/6
Memoria de Datos
Descripcin
Es una memoria que permite almacenar temporalmente datos,
como si fuera una memoria del sistema.
Cdigo
entity DataMem is
Port ( i_addr : in STD_LOGIC_VECTOR (31 downto 0);
i_din : in STD_LOGIC_VECTOR (31 downto 0);
i_clk : in STD_LOGIC;
i_we : in STD_LOGIC;
o_dat : out STD_LOGIC_VECTOR (31 downto 0));
end DataMem;
architecture Behavioral of DataMem is
____________________________
Noviembre/2006/6
type RAM_type is array (0 to 511) of std_logic_vector(31 downto

0);
signal RAM : RAM_type;
signal addr_temp: STD_LOGIC_VECTOR (31 downto 0);
begin
process (i_clk, i_addr)
begin
addr_temp <= i_addr;

if (rising_edge(i_clk)) then
o_dat <= RAM(conv_integer(addr_temp(10 downto 2)));
if (i_we = '1') then
RAM(conv_integer(addr_temp(10 downto 2))) <= i_din;
end if;
end if;
end process;
end Behavioral;
2. Controlador de Program Counter:
____________________________
Noviembre/2006/6
Descripcin
Recibe un tipo de salto y permite seleccionar que seal recibe

el program counter.
Cdigo
entity pccontrol is
Port ( i_pcsel : in STD_LOGIC_VECTOR (1 downto 0);
i_eq : in STD_LOGIC;
o_pcsel : out STD_LOGIC_VECTOR (1 downto 0));
end pccontrol;
architecture Behavioral of pccontrol is
begin
process (i_pcsel, i_eq)
begin
if (i_pcsel = "00") then -- cualquier instruccion

o_pcsel <= "00";
elsif (i_pcsel = "01") then -- BEQ
if (i_eq = '1') then
____________________________
Noviembre/2006/6
o_pcsel <= "01";

else
o_pcsel <= "00";
end if;
elsif (i_pcsel = "10") then -- J
o_pcsel <= "10";
elsif (i_pcsel = "11") then -- BNE
if (i_eq = '1') then
o_pcsel <= "00";
else
o_pcsel <= "11";
end if;
end if;
end process;
end Behavioral;
3. Entendedor de Jump (de 26 bits a 32 bits):
____________________________
Noviembre/2006/6
Descripcin
Recibe el numero de 26 bits de la instruccin J y lo convierte a

un numero de 32 bits .
Cdigo
entity ext26b is
Port ( i_dat : in STD_LOGIC_VECTOR (25 downto 0);
o_ext : out STD_LOGIC_VECTOR (31 downto 0));
end ext26b;
architecture Behavioral of ext26b is
begin
process (i_dat)
begin
if (i_dat(25) = '1') then

o_ext <= b"1111" & i_dat & b"00";
else
o_ext <= b"0000" & i_dat & b"00";
____________________________
Noviembre/2006/6
end if;
end process;
end Behavioral;
4. Decodificador de Opcodes (modificado):
Descripcin
Permite controlar las diferentes seales del sistema

dependiendo de la instruccin a la que es sometido.
Cdigo
entity decopcode is
Port ( i_opcode : in std_logic_vector(5 downto 0);
i_funct : in std_logic_vector(5 downto 0);
o_aluctrl : out std_logic_vector(3 downto 0);
o_alusrc : out std_logic;
o_regdest : out std_logic;
o_regwr : out std_logic;
o_memwr : out std_logic;
____________________________
Noviembre/2006/6
o_memtoreg : out std_logic;

o_pcsrc : out std_logic_vector(1 downto 0)); -- 00 si
contador regular, 01 si BEQ, 10 si J, 11 si reset.
end decopcode;
architecture Behavioral of decopcode is
begin
process (i_opcode, i_funct)
begin
case i_opcode is
when "000000" => -- tipo R
case i_funct is
when "000000" => o_aluctrl <= "1001"; -- SLL
when "000010" => o_aluctrl <= "1010"; -- SRL
when "100100" => o_aluctrl <= "0000"; -- AND
when "100101" => o_aluctrl <= "0001"; -- OR
when "100001" => o_aluctrl <= "0010"; -- ADDU, era ADD
(100000)
when "100011" => o_aluctrl <= "0110"; -- SUBU, era SUB
(100010)
when "101010" => o_aluctrl <= "0111"; -- SLT
____________________________
Noviembre/2006/6
when "100110" => o_aluctrl <= "1100"; -- XOR

when others => o_aluctrl <= "0000";
end case;
o_alusrc <= '0';
o_regdest <= '1';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '1';
o_pcsrc <= "00";
when "000010" => o_aluctrl <= "0000"; -- J
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '0';
o_pcsrc <= "10";
when "000100" => o_aluctrl <= "0000"; -- BEQ
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
____________________________
Noviembre/2006/6
o_regwr <= '0';

o_pcsrc <= "01";
when "000101" => o_aluctrl <= "0000"; -- BNE
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '0';
o_pcsrc <= "11";
when "001100" => o_aluctrl <= "0000"; -- ANDI
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '1';
o_pcsrc <= "00";
when "001101" => o_aluctrl <= "0001"; -- ORI
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
____________________________
Noviembre/2006/6
o_regwr <= '1';

o_pcsrc <= "00";
when "001001" => o_aluctrl <= "0010"; -- ADDIU
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '1';
o_pcsrc <= "00";
when "001010" => o_aluctrl <= "0111"; -- SLTI
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
o_regwr <= '1';
o_pcsrc <= "00";
when "001110" => o_aluctrl <= "1100"; -- XORI
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '0';
____________________________
Noviembre/2006/6
o_regwr <= '1';

o_pcsrc <= "00";
when "100011" => o_aluctrl <= "1111"; -- LW
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '0';
o_memtoreg <= '1';
o_regwr <= '1';
o_pcsrc <= "00";
when "101011" => o_aluctrl <= "1111"; -- SW
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '1';
o_memtoreg <= '1';
o_regwr <= '0';
o_pcsrc <= "00";
when others => o_aluctrl <= "0000"; --
o_alusrc <= '1';
o_regdest <= '0';
o_memwr <= '1';
o_memtoreg <= '1';
____________________________
Noviembre/2006/6
o_regwr <= '0';

o_pcsrc <= "00";
end case;
end process;
end Behavioral;
5. ALU (Modificada):
Descripcin
Este componente realiza los calculos lgicos que se requieren

por las operaciones soportadas por el sistema.
Cdigo
entity alu32b is
Port ( in_a : in std_logic_vector(31 downto 0);
in_b : in std_logic_vector(31 downto 0);
in_s : in std_logic_vector(4 downto 0);
in_funct : in std_logic_vector(3 downto 0);
o_y : out std_logic_vector(31 downto 0);
o_eq : out std_logic);
____________________________
Noviembre/2006/6
end alu32b;
architecture Behavioral of alu32b is
begin
process (in_a, in_b, in_funct)
begin
case in_funct is
when "0000" => o_y <= in_a AND in_b;
when "0001" => o_y <= in_a OR in_b;
when "0010" => o_y <= in_a + in_b;
when "0110" => o_y <= in_a - in_b;
when "0111" => if (in_a < in_b) then
o_y <= (others => '1');
else
o_y <= (others => '0');
end if;
when "1100" => o_y <= in_a XOR in_b;
when "1001" => case in_s is
when "00000" => o_y <= in_b;
when "00001" => o_y <= in_b(30 downto 0) & '0';
____________________________
Noviembre/2006/6
when "00010" => o_y <= in_b(29 downto 0) & "00";

when "01001" => o_y <= in_b(22
downto 0) & "000000000";
when "01011" => o_y <= in_b(20 downto 0) &
"00000000000";
"000000000000";
"0000000000000";
"00000000000000";
"000000000000000";
"0000000000000000";
____________________________
Noviembre/2006/6

"00000000000000000";
"000000000000000000";
"0000000000000000000";
"00000000000000000000";
"000000000000000000000";
"0000000000000000000000";
"00000000000000000000000";
"000000000000000000000000";
"0000000000000000000000000";
"00000000000000000000000000";
"000000000000000000000000000";
"0000000000000000000000000000";
____________________________
Noviembre/2006/6

"00000000000000000000000000000";
"000000000000000000000000000000";
when "11111" => o_y <= in_b(0) &
"0000000000000000000000000000000";
when others => o_y <= in_b(0) &
"0000000000000000000000000000000";
end case;
when "1010" => case in_s is
when "00000" => o_y <= in_b;
when "00001" => o_y <= '0' & in_b(30 downto 0);
when "00010" => o_y <= "00" & in_b(29 downto 0);
when "00101" => o_y <= "00000"
& in_b(26 downto 0);
____________________________
Noviembre/2006/6
when "01011" => o_y <= "00000000000" & in_b(20 downto

0);
when "01100" => o_y <= "000000000000" & in_b(19 downto
0);
when "01101" => o_y <= "0000000000000" & in_b(18
downto 0);
when "01110" => o_y <= "00000000000000" & in_b(17
downto 0);
when "01111" => o_y <= "000000000000000" & in_b(16
downto 0);
when "10000" => o_y <= "0000000000000000" & in_b(15
downto 0);
when "10001" => o_y <= "00000000000000000" & in_b(14
downto 0);
when "10010" => o_y <= "000000000000000000" & in_b(13
downto 0);
when "10011" => o_y <= "0000000000000000000" & in_b(12
downto 0);
when "10100" => o_y <= "00000000000000000000" &
in_b(11 downto 0);
when "10101" => o_y <= "000000000000000000000" &
in_b(10 downto 0);
when "10110" => o_y <= "0000000000000000000000" &
in_b(9 downto 0);
____________________________
Noviembre/2006/6
when "10111" => o_y <= "00000000000000000000000" &

in_b(8 downto 0);
when "11000" => o_y <= "000000000000000000000000" &
in_b(7 downto 0);
when "11001" => o_y <= "0000000000000000000000000" &
in_b(6 downto 0);
when "11010" => o_y <= "00000000000000000000000000" &
in_b(5 downto 0);
when "11011" => o_y <= "000000000000000000000000000"
& in_b(4 downto 0);
when "11100" => o_y <= "0000000000000000000000000000"
& in_b(3 downto 0);
when "11101" => o_y <=
"00000000000000000000000000000" & in_b(2 downto 0);
when "11110" => o_y <=
"000000000000000000000000000000" & in_b(1 downto 0);
when "11111" => o_y <=
"0000000000000000000000000000000" & in_b(0);
when others => o_y <=
"0000000000000000000000000000000" & in_b(0);
end case;
when "1111" => o_y <= in_a;
when others => o_y <= (others => '1');
end case;
____________________________
Noviembre/2006/6
if (in_a = in_b) then

o_eq <= '1';
else
o_eq <= '0';
end if;
end process;
end Behavioral;
6. Modulo principal (DATAPATH 3):
Descripcin
Es el modulo principal de todo el sistema .
Cdigo
entity Datapath3 is
Port ( i_clk : in std_logic;
i_rst : in std_logic;
____________________________
Noviembre/2006/6
i_we : in std_logic;
i_sel : in std_logic_vector(1 downto 0);
o_output: out std_logic_vector(7 downto 0);
o_prueba: out std_logic_vector(3 downto 0));
end Datapath3;
architecture Structural of Datapath3 is
component Datapath1 is
Port ( i_rst : in std_logic;
i_clk : in std_logic;
i_en : in std_logic;
i_eq : in std_logic;
i_pcsrc : in std_logic_vector(1 downto 0);
i_offset : in std_logic_vector(25 downto 0);
o_data : out std_logic_vector(31 downto 0));
end component;
component Regfile is
port(i_wd : in std_logic_vector(31 downto 0); -- Input Data
____________________________
Noviembre/2006/6
i_ws : in std_logic_vector(4 downto 0); -- Input

Address
i_rs1 : in std_logic_vector(4 downto 0); -- Output
Address 1
i_rs2 : in std_logic_vector(4 downto 0); -- Output
Address 2
i_we : in std_logic; -- Write
Enable
i_clk : in std_logic; -- Global Clk
o_rd1 : out std_logic_vector(31 downto 0); -- Output

Data 1
o_rd2 : out std_logic_vector(31 downto 0) -- Output
Data 2
);
end component;
component alu32b is
Port ( in_a : in std_logic_vector(31 downto 0);
in_b : in std_logic_vector(31 downto 0);
in_s : in std_logic_vector(4 downto 0);
in_funct : in std_logic_vector(3 downto 0);
o_y : out std_logic_vector(31 downto 0);
____________________________
Noviembre/2006/6
o_eq : out std_logic);

end component;
component decopcode is
Port ( i_opcode : in std_logic_vector(5 downto 0);
i_funct : in std_logic_vector(5 downto 0);
o_aluctrl : out std_logic_vector(3 downto 0);
o_alusrc : out std_logic;
o_regdest : out std_logic;
o_regwr : out std_logic;
o_memwr : out std_logic;
o_memtoreg : out std_logic;
o_pcsrc : out std_logic_vector(1 downto 0));
end component;
component extimmed is
Port ( i_immed : in STD_LOGIC_VECTOR (15 downto 0);
o_ext : out STD_LOGIC_VECTOR (31 downto 0));
end component;
component mux32b2a1 is
____________________________
Noviembre/2006/6
Port ( i_a : in STD_LOGIC_VECTOR (31 downto 0);

i_b : in STD_LOGIC_VECTOR (31 downto 0);
i_sel : in STD_LOGIC;
o_y : out STD_LOGIC_VECTOR (31 downto 0));
end component;
Port ( i_a : in STD_LOGIC_VECTOR (4 downto 0);
i_b : in STD_LOGIC_VECTOR (4 downto 0);
i_sel : in STD_LOGIC;
end component;
component div_frec is
Port ( i_clk : in STD_LOGIC;
i_rst : in STD_LOGIC;
o_clk : out STD_LOGIC);
end component;
Port ( i_d0 : in STD_LOGIC_VECTOR (7 downto 0);
____________________________
Noviembre/2006/6
i_d1 : in STD_LOGIC_VECTOR (7 downto 0);

i_sel : in STD_LOGIC_VECTOR (1 downto 0);
end component;
component DataMem is
Port ( i_addr : in STD_LOGIC_VECTOR (31 downto 0);
i_din : in STD_LOGIC_VECTOR (31 downto 0);
i_clk : in STD_LOGIC;
i_we : in STD_LOGIC;
o_dat : out STD_LOGIC_VECTOR (31 downto 0));
end component;
signal instruccion: std_logic_vector(31 downto 0);

signal alures: std_logic_vector(31 downto 0);
signal aluoper: std_logic_vector(3 downto 0);
signal alusrc, regdest, regwr, memwr, memtoreg, alueq:
STD_LOGIC;
signal pcsrc : std_logic_vector(1 downto 0);
____________________________
Noviembre/2006/6
signal add_ws: std_logic_vector(4 downto 0);

signal dat_rd1, dat_rd2, dat_ext, dat_alu, dat_mem, dat_2reg:
std_logic_vector(31 downto 0);
signal nuevoclk: std_logic;
begin
datapath: Datapath1 port map(i_rst => i_rst, i_clk => nuevoclk,

o_data => instruccion, i_en => i_we, i_pcsrc => pcsrc, i_offset
=> instruccion(25 downto 0), i_eq => alueq);
decopcod: decopcode port map(i_opcode => instruccion(31
downto 26), i_funct => instruccion(5 downto 0), o_aluctrl =>
aluoper, o_alusrc => alusrc, o_regdest => regdest, o_memwr =>
memwr, o_memtoreg => memtoreg, o_pcsrc => pcsrc, o_regwr
=> regwr);
muxde5b: mux5b2a1 port map(i_a => instruccion(20 downto
16), i_b => instruccion(15 downto 11), i_sel => regdest, o_y =>
add_ws);
extinmed: extimmed port map(i_immed => instruccion(15
downto 0), o_ext => dat_ext);
regfle: Regfile port map(i_ws => add_ws, i_wd => dat_2reg,
i_rs1 => instruccion(25 downto 21), i_rs2 => instruccion(20
downto 16), i_we => regwr, i_clk => nuevoclk, o_rd1 =>
dat_rd1, o_rd2 => dat_rd2);
____________________________
Noviembre/2006/6
muxde32b: mux32b2a1 port map(i_a => dat_rd2, i_b => dat_ext,

i_sel => alusrc, o_y => dat_alu);
alu: alu32b port map(in_a => dat_rd1, in_b => dat_alu,
in_s => instruccion(10 downto 6), in_funct => aluoper, o_y =>
alures, o_eq => alueq);
datam : DataMem port map(i_addr => alures, i_din => dat_rd2,
i_clk => nuevoclk, i_we => memwr, o_dat => dat_mem);
divfrec: div_frec port map(i_clk => i_clk, i_rst => i_rst, o_clk
=> nuevoclk);
muxreg : mux32b2a1 port map(i_a => alures, i_b => dat_mem,
i_sel => memtoreg, o_y => dat_2reg);
muxde8b: mux8b4a1 port map(i_d0 => alures(7 downto 0), i_d1
=> alures(15 downto 8), i_d2 => alures(23 downto 16), i_d3
=> alures(31 downto 24), i_sel => i_sel, o_y => o_output);
process (aluoper)
begin
o_prueba <= aluoper;
end process;
end Structural;
____________________________
Noviembre/2006/6
CONCLUSIONES Y RECOMENDACIONES
El sistema tiene algunos problemas, principalmente basados en

las operaciones de salto, ya que toman un ciclo adicional para
realizarse, sin comprometer los resultados de las operaciones.
Aunque el shift fue optimizado por el sintetizador, la forma en
que se aplic es una manera muy poco optimizada para
realizarse.
De resto, el sistema es capaz de incorporar todas las dems
funciones, sin problemas.
Referencias:
http://mixteco.utm.mx/~merg/AC/pdfs/DataPath2.pdf
http://mixteco.utm.mx/~merg/AC/pdfs/Unit_4_Part_1.pdf
http://isc.utp.edu.co/~michaelm/
MIPS Instruction Set Referente, http://www.mips.com/
____________________________
Noviembre/2006/6
____________________________

Reporte Arqui

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Reporte Arqui

Diunggah oleh

Hak Cipta:

Format Tersedia

Introduccin

Se disear una implementacin que incluya las instrucciones ms

Datapath (camino de datos)

Op: Es el cdigo de instruccin

Formato de instruccin Tipo l

rs: Es donde se guardar el primer registro fuente.

Formato de instruccin en J(salta incondicional)

Bits 31-26: opcode - Instrucciones

Desactivado: el valor presente en la entrada WriteData se enva desde la

Un datapath es una coleccin de unidades funcionales tales como unidades

PC: Es un registro del procesador de un computador que indica la posicin

Banco de registros: Esta estructura contiene una coleccin de registros en la

escritura solo se realiza en algunas instrucciones, por lo cual se debe incluir

Las instrucciones de carga y almacenamiento nos permiten la transferencia

Para este tipo de instrucciones necesitamos de otros elementos como: la

Las instrucciones tipo R y de acceso a memoria utilizan a la ALU y el primer

Teniendo el control ALU, es posible realizar el control principal. El control

architecture Behavioral of DataMem is

type RAM_type is array (0 to 511) of std_logic_vector(31 downto

addr_temp <= i_addr;

2. Controlador de Program Counter:

Recibe un tipo de salto y permite seleccionar que seal recibe

architecture Behavioral of pccontrol is

if (i_pcsel = "00") then -- cualquier instruccion

o_pcsel <= "01";

3. Entendedor de Jump (de 26 bits a 32 bits):

Recibe el numero de 26 bits de la instruccin J y lo convierte a

architecture Behavioral of ext26b is

if (i_dat(25) = '1') then

4. Decodificador de Opcodes (modificado):

Permite controlar las diferentes seales del sistema

o_memtoreg : out std_logic;

architecture Behavioral of decopcode is

when "100110" => o_aluctrl <= "1100"; -- XOR

o_regwr <= '0';

o_regwr <= '1';

o_regwr <= '1';

o_regwr <= '0';

Este componente realiza los calculos lgicos que se requieren

architecture Behavioral of alu32b is

when "00010" => o_y <= in_b(29 downto 0) & "00";

when "10001" => o_y <= in_b(14 downto 0) &

when "11101" => o_y <= in_b(2 downto 0) &

when "01011" => o_y <= "00000000000" & in_b(20 downto

when "10111" => o_y <= "00000000000000000000000" &

if (in_a = in_b) then

6. Modulo principal (DATAPATH 3):

Es el modulo principal de todo el sistema .

architecture Structural of Datapath3 is

i_ws : in std_logic_vector(4 downto 0); -- Input

o_rd1 : out std_logic_vector(31 downto 0); -- Output

o_eq : out std_logic);

Port ( i_a : in STD_LOGIC_VECTOR (31 downto 0);

i_d1 : in STD_LOGIC_VECTOR (7 downto 0);

signal instruccion: std_logic_vector(31 downto 0);

signal add_ws: std_logic_vector(4 downto 0);

datapath: Datapath1 port map(i_rst => i_rst, i_clk => nuevoclk,

muxde32b: mux32b2a1 port map(i_a => dat_rd2, i_b => dat_ext,

El sistema tiene algunos problemas, principalmente basados en

Anda mungkin juga menyukai