Reporte, Datapath

- OBJETIVO:
En este proyecto vamos a aprender cómo funciona y cómo implementar un datapath

básico para operaciones de tipo R. para nuestra implementación vamos a considerar 4
operaciones, SUMA RESTA, AND, OR.
Basándonos en el siguiente diagrama:
Como observaciones tenemos que para nuestro diseño únicamente tomaremos en cuenta los
siguientes bloques:
- REGISTERS
- ALU
- CONTROL
- CONTROL DE LA ALU
Los multiplexores no serán considerados en este caso ya que únicamente se considerara un solo
formato por lo que considero que no son necesarios.
Basándonos en el siguiente formato que corresponde a las instrucciones de tipo R:

Para controlar las operaciones que va a manejar la ALU vamos a basarnos en la siguiente tabla:
- IMPLENTACION CONCEPTUAL:
Nuestro datapath fue ordenado de la siguiente manera:
Este bloque elegirá el tipo de

formato de la operación a CONTROL
Una vez decodificado los registros, vamos a
realizar (en nuestro caso es la
interconectar los dos buses de salida del
tipo R y el RegWrite.
register file a las entradas de 32 bits de la ALU.
INSTRUCCION REGISTER FILE ALU

32 BITS
Va a fragmentar el registro de 32 bits en el formato

tipo R y a su vez dichos registros resultantes se
decodificaran para tener cadenas de 32 bits para ser RESULTADO
operados en la ALU 32 BITS
CONTROL DE LA ALU
Elegirá la operación que ejecutara la

ALU, en este caso el carry de entrada lo
proporcionara este bloque
- CODIGOS QUE FUERON USADOS PARA EL DATAPATH
--- REGISTER FILE ---

library ieee;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;
entity Register_File is
port( ----- ENTRADAS -----
-- Rb Ra Rd
Reg2,Reg1,WriteReg : in std_logic_vector (4 downto 0); -- WriteReg es el registro de escritura
WriteData : in std_logic_vector(31 downto 0); -- se escribira el resultado de la ALU
RegWrite : in std_logic;
----- SALIDAS -----
RegO1,RegO2: out std_logic_vector(31 downto 0));
end Register_File;
architecture arch_Register_File of Register_File is

signal RD,WD : std_logic_vector(31 downto 0);
signal R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13,
R14,R15,R16,R17,R18,R19,R20,R21,R22,R23,R24,R25,R26,R27,R28,
R29,R30,R31 : std_logic_vector(31 downto 0);
begin
R0 <= "00000000000000000000000000000001"; --$zero
R1 <= "00000000000000000000000000000010"; --$at
R2 <= "00000000000000000000000000000100"; --$v0
R3 <= "00000000000000000000000000001000"; --$v1
R4 <= "00000000000000000000000000010000"; --$a0
R5 <= "00000000000000000000000000100000"; --$a1
R6 <= "00000000000000000000000001000000"; --$a2
R7 <= "00000000000000000000000010000000"; --$a3
R8 <= "00000000000000000000000100000000"; --$t0
R9 <= "00000000000000000000001000000000"; --$t1
R10 <= "00000000000000000000010000000000"; --$t2
R11 <= "00000000000000000000100000000000"; --$t3
R12 <= "00000000000000000001000000000000"; --$t4
R13 <= "00000000000000000010000000000000"; --$t5
R14 <= "00000000000000000100000000000000"; --$t6
R15 <= "00000000000000001000000000000000"; --$t7
R16 <= "00000000000000010000000000000000"; --$s0
R17 <= "00000000000000100000000000000000"; --$s1
R18 <= "00000000000001000000000000000000"; --$s2
R19 <= "00000000000010000000000000000000"; --$s3
R20 <= "00000000000100000000000000000000"; --$s4
R21 <= "00000000001000000000000000000000"; --$s5
R22 <= "00000000010000000000000000000000"; --$s6
R23 <= "00000000100000000000000000000000"; --$s7
R24 <= "00000001000000000000000000000000"; --$t8
R25 <= "00000010000000000000000000000000"; --$t9
R26 <= "00000100000000000000000000000000"; --$k0
R27 <= "00001000000000000000000000000000"; --$k1
R28 <= "00010000000000000000000000000000"; --$gp
R29 <= "00100000000000000000000000000000"; --$sp
R30 <= "01000000000000000000000000000000"; --$fp
R31 <= "10000000000000000000000000000000"; --$ra
process(Reg1,Reg2,WriteReg,WriteData,RegWrite)
begin
IF(RegWrite='1') then
------------------------ REGISTRO RS ------------------------------------------
if (Reg1 = "00000") then RegO1<=R0;
elsif (Reg1 = "00001") then RegO1<=R1; elsif (Reg1 = "00010") then RegO1<=R2;
elsif (Reg1 = "11111") then RegO1<=R31; end if;
------------------------ REGISTRO RT ------------------------------------------
if (Reg2 = "00000") then RegO2<=R0;
elsif (Reg2 = "11111") then RegO2<=R31; end if;
------------------------ REGISTRO RD ------------------------------------------
if (WriteReg = "01000") then RD<=R8; elsif (WriteReg = "01001") then RD<=R9;
elsif (WriteReg = "01010") then RD<=R10; elsif (WriteReg = "01011") then RD<=R11;
elsif (WriteReg = "10110") then RD<=R22; elsif (WriteReg = "10111") then RD<=R23; end if;
RD <= WriteData;
ELSE
RD <= "00000000000000000000000000000000";
end if;
end process;
end arch_Register_File;
--- UNIDAD DE CONTROL ---

library ieee;
entity Control is
port( Instru : in std_logic_vector(5 downto 0); -- op que va de 31 a 26
-----------------------------------------------------------------------------
ALUop1 : out std_logic_vector(1 downto 0);
RegWrite1 : out std_logic );
end Control;
architecture arch_Control of Control is

begin
----- SELECCIONA EL TIPO DE OPERACION (R,I,J) -----
with Instru select
ALUop1 <= "10" when "000000",
"00" when others;
----- SELECCIONA LA ESCRITURA EN EL REGISTRO -----
with Instru select
RegWrite1 <= '1' when "000000",
'0' when others;
end arch_Control;
--- CONTROL DE LA ALU---
library ieee;
entity ALU_control is
port( ALUop2: in std_logic_vector(1 downto 0);
funct : in std_logic_vector(5 downto 0); -- funct que va de 5 a 0
----------------------------------------------
carry_in : out std_logic;
control : out std_logic_vector(3 downto 0) );
end ALU_control;
architecture arch_ALU_control of ALU_control is

signal AUX : std_logic_vector(3 downto 0);
begin
control <= "0010" when (ALUop2="00") else
"0110" when (ALUop2="01") else
AUX ;
------------- SELECTOR DE OPERACIONES ---------
with funct select
AUX <= "0010" when "100000", --SUMA
"0110" when "100010", --RESTA
"0000" when "100100", --AND
"0001" when "100101", --OR
"0111" when others; --SLT
------------- CARRY DE ENTRADA ----------------

carry_in <= '1' when (funct="100010") else
'0';
end arch_ALU_control;
--- UNIDAD ARITHMETICA LOGICA ---

Library ieee;
entity ALU_32 is
port( ----- ENTRADAS -----
A,B : in std_logic_vector(31 downto 0);
operacion : in std_logic_vector( 3 downto 0); --- selector de operaciones
Cin : in std_logic;
----- SALIDAS -----
resultadoALU : out std_logic_vector(31 downto 0); --- resultado de la operacion
Cout,cero,overflow : out std_logic);
end ALU_32;
architecture arch_ALU_32 of ALU_32 is

------------------- SUMADOR DE 1 BIT ------------------------
COMPONENT sumador_1bit
port( A,B : in std_logic;
cI : in std_logic;
COUT : out std_logic;
SR : out std_logic );
end COMPONENT;
------------------------------------------------------------
signal X0,X1,X2,X3,X4,X5,X6,X7,X8,X9,X10,X11,X12,X13,X14,X15,X16,
X17,X18,X19,X20,X21,X22,X23,X24,X25,X26,X27,X28,X29,X30,X31 : std_logic;
signal AUX,AUX2,CINaux: std_logic;

signal BN,RES,SUMA,RESTA,ANDp,ORp,NORp,SET,SLT: std_logic_vector(31 downto 0);
begin
----------------------------- SUMA Y RESTA ---------------------------------------
BN <= not(B) when (Cin='1') else B;
----------------------------- ALUS DE 1 BIT --------------------------------------
b0 : sumador_1bit port map (A=>A(0), B=>BN(0), cI=>Cin, COUT=>X0, SR=>RES(0) );
b1 : sumador_1bit port map (A=>A(1), B=>BN(1), cI=>X0, COUT=>X1, SR=>RES(1) );
Cout<=X31;
---------------------------------------------------------------------------------------------
-- SUMA <= RES when (Cin='0');
RESTA <= RES when (Cin='1') else RES;
---------- OPERACIONES LOGICAS --------------
ANDp <= A AND B;
ORp <= A OR B;
NORp <= "0000000000000000000000000000000"& AUX2;
SLT <= "0000000000000000000000000000000"& RES(31);
----------- CERO Y OVERFLOW ------------------

AUX <= RES(0) or RES(1) or RES(2) or RES(3) or RES(4) or RES(5) or RES(6) or RES(7) or
RES(8) or RES(9) or
RES(10) or RES(11) or RES(12) or RES(13) or RES(14) or RES(15) or RES(16) or RES(17) or
RES(18) or RES(19) or
RES(20) or RES(21) or RES(22) or RES(23) or RES(24) or RES(25) or RES(26) or RES(27) or
RES(28) or RES(29) or
RES(30) or RES(31);
cero <= not(AUX);

AUX2 <= not(AUX);
overflow <= X30 xor X31;
----------- SELECTOR DE OPERACION -------------

with operacion select
resultadoALU <= RES when "0010",
RESTA when "0110",
--------------------
ANDp when "0000",
ORp when "0001",
SLT when others;
end arch_ALU_32;
--- TEST BENCH ---
library ieee;
entity tb_datapath is
end tb_datapath;
architecture tb_arch of tb_datapath is

COMPONENT Datapath
port( Instruccion : in std_logic_vector(31 downto 0);
C_IN, C_OUT,REG_WRITE : out std_logic;

RRs,RRt,RRd,Shamtt : out std_logic_vector(4 downto 0);
Functt, Opp : out std_logic_vector(5 downto 0);
RD1,RD2,WD : out std_logic_vector(31 downto 0);
Resultado : out std_logic_vector(31 downto 0) );
end COMPONENT;
signal INSTRUCCION : std_logic_vector(31 downto 0);

signal RS,RT,RD,SHAMT : std_logic_vector(4 downto 0);
signal OP, FUNCT : std_logic_vector(5 downto 0);
signal RESULTADO : std_logic_vector(31 downto 0);
signal READATA1,READATA2,WRITEDATA : std_logic_vector(31 downto 0);
signal CARRYIN, CARRYOUT,REGWRITE : std_logic;
begin
uut: datapath
port map( instruccion=>INSTRUCCION, RRs=>RS, RRt=>RT, RRd=>RD, Shamtt=>SHAMT,
Functt=>FUNCT, Opp=>OP,Resultado=>RESULTADO,
RD1=>READATA1, RD2=>READATA2, WD=>WRITEDATA, C_IN=>CARRYIN,
C_OUT=>CARRYOUT, REG_WRITE=>REGWRITE);
process
-------------------- INSTRUCCIONES ----------------------
begin -- OP RS RT RD SHAMT FUNCT
INSTRUCCION <= "000000"&"10011"&"10110"&"10000"&"00000"&"100000"; ----- SUMA
wait for 200 ns;
----------------------------------------------------------
INSTRUCCION <= "000000"&"00101"&"00010"&"10001"&"00000"&"100010"; ----- RESTA
wait for 200 ns;
----------------------------------------------------------
INSTRUCCION <= "000000"&"10010"&"10100"&"10101"&"00000"&"100100"; ----- AND
wait for 200 ns;
----------------------------------------------------------
INSTRUCCION <= "000000"&"01110"&"00010"&"10111"&"00000"&"100101"; ----- OR
wait for 200 ns;
----------------------------------------------------------
end process;
end tb_arch;
- CONCLUSION
Este proyecto me ayudo a entender el funcionamiento y la implementación de un
microprocesador, además de que se obtuvo una mejor comprensión acerca de los tipos de
instrucciones y su implementación en un diseño, me resulto muy interesante el proyecto.
Por ultimo llego a la conclusión de que su implementación es muy flexible y fácil de

implementar.

Reporte, Datapath

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Reporte, Datapath

Cargado por

Copyright:

Formatos disponibles

- OBJETIVO:

En este proyecto vamos a aprender cómo funciona y cómo implementar un datapath

Basándonos en el siguiente diagrama:

Basándonos en el siguiente formato que corresponde a las instrucciones de tipo R:

Este bloque elegirá el tipo de

INSTRUCCION REGISTER FILE ALU

Va a fragmentar el registro de 32 bits en el formato

Elegirá la operación que ejecutara la

--- REGISTER FILE ---

architecture arch_Register_File of Register_File is

--- UNIDAD DE CONTROL ---

architecture arch_Control of Control is

architecture arch_ALU_control of ALU_control is

------------- CARRY DE ENTRADA ----------------

--- UNIDAD ARITHMETICA LOGICA ---

architecture arch_ALU_32 of ALU_32 is

signal AUX,AUX2,CINaux: std_logic;

----------- CERO Y OVERFLOW ------------------

cero <= not(AUX);

----------- SELECTOR DE OPERACION -------------

architecture tb_arch of tb_datapath is

C_IN, C_OUT,REG_WRITE : out std_logic;

signal INSTRUCCION : std_logic_vector(31 downto 0);

Por ultimo llego a la conclusión de que su implementación es muy flexible y fácil de

También podría gustarte