Sesion 8

Sesión 8: Diseño de un Computador con VHDL
S8 1
VHDL: de la tecnología a la arquitectura de computadores. José J. Ruz Ortiz, Síntesis 1997
Definición del Computador
Memoria y registros
• Memoria principal de 256 palabras de 12 bits (256x12)
• Un registro acumulador (AC) también de 12 bits.
• Registro de códigos de condición de 2 bits: Z y N
11 0
11 0
000
ACUMULADOR
(AC)
MEMORIA 1 0
(MEM) NZ
FFF
Formato de las instrucciones

• Todas las instrucciones tienen longitud fija (12 bits)
• Están compuestas por:
• código de operación (COP) de 4 bits (los 4 más significativos)
• dirección o un operando de 8 bits (los menos significativos).
11 8 7 0
COP DIRECCION/OPERANDO
S8 2
Repertorio de instrucciones
11 instrucciones:
• 3 de carga y almacenamiento (LDA, STA, LDAI)

• 3 aritmético-lógicas (SUM, SUMI, NOR)
• 4 de salto condicional (JZ, JNZ, JN, JNN)
• 1 instrucción de parada (HALT)
Nombre Simbólico DIR/OPE COP Significado
LDA DIR 0001 AC <-- MEM(DIR)

STA DIR 0010 MEM(DIR) <-- <AC>
SUM DIR 0011 AC <-- <AC> + MEM(DIR)
LDAI OPE 0100 AC <-- 0000&OPE
SUMI OPE 0101 AC <-- <AC> + 0000&OPE
NOR DIR 0110 AC <-- <AC> NOR MEM(DIR)
JZ DIR 0111 PC <-- DIR SI <Z> = 1
JNZ DIR 1000 PC <-- DIR SI <Z> = 0
JN DIR 1001 PC <-- DIR SI <N> = 1
JNN DIR 1010 PC <-- DIR SI <N> = 0
HALT - 0000 parada
S8 3
Ejemplos de programas
Ejemplo 1 Ejemplo 2
Suma 3 al contenido de la posición de memoria 4 y Inicializa 10 posiciones de memoria (de la 20 a la 29)
almacena el resultado en la posición de memoria 5. con un contenido igual a su dirección.
Simbólico Binario Simbólico Binario

LDAI 3 0100 00000011 0 LDA (STA índice) 0001 00000100
SUM 4 0011 00000100 1 SUMI 1 0101 00000001
STA 5 0010 00000101 2 STA (STA índice+1 ) 0010 00000100
HALT 0000 00000000 3 LDA índice 0001 00001110
4 STA índice 0010 00010011
5 SUMI 1 0101 00000001
6 STA índice 0010 00001110
Para referenciar posiciones de memoria consecutivas 7 LDA limite 0001 00001101
(indexación) modificamos instrucciones en tiempo de 8 NOR limite 0110 00001101
ejecución, concretamente, sumando un 1 a la 9 SUMI 1 0101 00000001
instrucción STA índice (inicialmente en binario
10 SUM índice 0011 00001110
001000010011) de la posición 4.
11 JNZ 0 1000 00000000
De esa forma, cada vez que se recorre el ciclo que 12 HALT 0000 00000000
constituye el programa, la instrucción STA índice 13 limite 000000011110
hace referencia a la dirección siguiente a la que 14 índice 000000010100
hizo en el recorrido anterior.
El ciclo se controla comprobando cuando el índice

toma el valor límite.
Para ello se realiza la resta limite - índice,

complementando a dos índice (complemento a
1 más 1) y sumando el resultado a índice
S8 4
Modelo de Comportamiento (1)
• Utiliza una entidad con un único proceso
• La entidad dispone de dos puertos binarios de entrada:
• Start: para iniciar la ejecución de un programa
• Reset: para reinicializar la máquina (poner a cero el contador de programa).
•Ambas entradas deberán activarse con flancos positivos.
• Para la memoria principal de 256x12 bits se utiliza un bit_vector
de longitud 12 sobre el rango de los naturales (0 a 255).
start • La carga inicial del programa a ejecutar se define como

el valor inicial de la variable que soporta la memoria (mem):
Computador
reset ARRAY (NATURAL RANGE 0 TO 255) OF bit_vector(11 DOWNTO 0);
VARIABLE mem : array_memoria :=
-- programa a ejecutar
("000100000100", -- 0 LDA (STA indice)
"010100000001", -- 1 SUMI 1
ENTITY computador IS "001000000100", -- 2 STA (STA indice+1)
PORT (start, reset : IN bit); "000100001110", -- 3 LDA indice
END computador; "001000010011", -- 4 STA indice
"010100000001", -- 5 SUMI 1
"001000001110", -- 6 STA indice
"000100001101", -- 7 LDA limite
Elemetos de modeloado (comportamiento): "011000001101", -- 8 NOR limite
• Zonas de datos (registros y memoria): variables "010100000001", -- 9 SUMI 1
"001100001110", -- 10 SUM indice
• Transferencias: asignación de variables "100000000000", -- 11 JNZ 0
"000000000000", -- 12 HALT
• Transformaciones: operadores y funciones
"000000011110", -- 13 limite
• Control del flujo: sentencias if y case. "000000010100", -- 14 indice
OTHERS => "000000000000");
S8 5
• Además de los registros visibles por el programador, esto es, ac y nz, utilizaremos variables para los registros
internos que tendrán existencia real en la máquina:
• registro contador de programa (pc)
• registro de instrucciones (ir)
• registro de direcciones de memoria (mar)
• registro de datos de memoria (mdr).
• Fases en la ejecución de una instrucción:

Búsqueda
•lee de memoria la instrucción apuntada por el pc, es decir, se transferirá el contenido del pc al mar
•lee la memoria almacenándose en el mdr el contenido de la posición indicada por el mar
•se transfiere el contenido del mdr al ir
•se incrementará el pc en 1 para que quede apuntando a la instrucción siguiente
Decodificación-ejecución.
• Específica para cada instrucción
ma r mem
pc
mdr
ac ir
S8 6
Transferencias elementales para cada instrucción

LDA STA SUM
mar <-- <ir> mdr <-- <ac> mar <-- <ir>
lectura mar <-- <ir> lectura
ac <-- <mdr> escritura ac <-- <ac>+<mdr>
n <-- <ac(11)> n <-- <ac(11)>
IF ac="000000000000" IF ac="000000000000"
THEN z <-- '1' THEN z <-- '1'
ELSE z <-- '0' ELSE z <-- '0
LDAI SUMI NOR
ac <-- <ir> mdr <-- <ir> mar <-- <ir>
n <-- <ac(11)> ac <-- <ac>+<mdr> lectura
IF ac="000000000000" n <-- <ac(11)> ac <-- <mdr>
THEN z <-- '1' IF ac="000000000000" n <-- <ac(11)>
ELSE z <-- '0' THEN z <-- '1' IF ac="000000000000"
ELSE z <-- '0' THEN z <-- '1'
ELSE z <-- '0'
JZ JNZ JN
IF nz(0) = '1' THEN pc <-- <ir> IF nz(0) = '0' THEN pc <-- <ir> IF nz(1) = '1' THEN pc <-- <ir>
JNN HALT
IF nz(1) = '0' THEN pc <-- <ir> stop <-- '1'
S8 7
Visualización del resultado de la ejecución
• Para trazar programas máquina será necesario que el modelo permita visualizar el contenido de registros y memoria.
• Como ambos están soportados por variables cuyos valores sólo son accesibles dentro del proceso, su visualización
debe hacerse cuando finalice la ejecución del programa máquina, antes de que el proceso pase al estado de espera.
• Visualizaremos los registros con el siguiente formato de línea:
<PC> = contenido del pc <AC> = contenido del ac <NZ> = contenido de nz
VARIABLE l : LINE;
CONSTANT c : STRING := " = ";

CONSTANT cac : STRING := " <AC> = ";
CONSTANT cpc : STRING := " <PC> = ";
CONSTANT cnz : STRING := " <NZ> = ";
WRITE(l,cpc); -- rotulo delpc, es decir, <PC> =

WRITE(l, pc); -- valor de pc visualización de registros
WRITE(l,cac); -- rótulo del ac, es decir, <AC> =
WRITE(l, ac); -- valor de ac
WRITE(l,cnz); -- rótulo del nz, es decir, <NZ> =
WRITE(l,nz); -- valor de nz
WRITELINE(OUTPUT,l);
FOR i IN 0 TO 29 LOOP
WRITE(l,i); -- valor de la dirección
WRITE(l, c); -- signo =
WRITE(l, mem(i)); -- valor del contenido de memoria visualización de memoria
WRITELINE(OUTPUT, l);
END LOOP;
S8 8
Código VHDL del modelo completo (1)
USE STD.TEXTIO.ALL;
USE WORK.utilidad.ALL;
ENTITY computador IS
PORT (start, reset : IN bit);
END computador;
ARCHITECTURE comportamiento OF computador IS
BEGIN
PROCESS(start, reset)
TYPE array_memoria IS
ARRAY (NATURAL RANGE 0 TO 255) OF bit_vector(11 DOWNTO 0);
VARIABLE mem : array_memoria :=
-- programa a ejecutar
("000100000100", -- 0 LDA (STA indice)
"010100000001", -- 1 SUMI 1
"001000000100", -- 2 STA (STA indice+1)
"000100001110", -- 3 LDA indice
"001000010011", -- 4 STA indice
"010100000001", -- 5 SUMI 1
"001000001110", -- 6 STA indice
"000100001101", -- 7 LDA limite
"011000001101", -- 8 NOR limite
"010100000001", -- 9 SUMI 1
"001100001110", -- 10 SUM indice
"100000000000", -- 11 JNZ 0
"000000000000", -- 12 HALT
"000000011110", -- 13 limite
"000000010100", -- 14 indice
OTHERS => "000000000000");
VARIABLE l : LINE;
CONSTANT c : STRING := " = ";
CONSTANT cac : STRING := " <AC> = ";
CONSTANT cpc : STRING := "<PC> = ";
CONSTANT cnz : STRING := " <NZ> = ";
VARIABLE mdr, mar, pc, ir, ac : bit_vector(11 DOWNTO 0);
VARIABLE nz : bit_vector(1 DOWNTO 0);
VARIABLE stop : bit;
S8 9
Modelo de Comportamiento (6) Código VHDL del modelo completo (2)
BEGIN
-- inicialización de la máquina (reset)
IF reset'EVENT AND reset = '1'
THEN
pc := "000000000000";
-- operación de la máquina
ELSIF start'EVENT AND START = '1'
THEN
WHILE stop = '0' LOOP
-- ciclo de búsqueda de la siguiente instrucción
mar := pc; -- mar <-- <pc>
mdr := mem(b_a_n(mar)); -- lectura
ir := mdr; -- ir <-- <mdr>
pc := n_a_b((b_a_n(pc) + 1), 12); -- pc <-- <pc> + 1
-- ciclo de ejecución
CASE ir(11 DOWNTO 8) IS
WHEN "0001" => -- LDA
mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir>
ac := mdr; -- ac <-- <mdr>
nz(1) := ac(11); -- n <-- <ac(11)>
IF ac = "000000000000" -- IF ac="000000000000"
THEN nz(0) := '1'; -- THEN z <-- '1'
ELSE nz(0) := '0'; -- ELSE z <-- '0'
END IF;
WHEN "0010" => -- STA
mdr := ac; -- mdr <-- <ac>
mem(b_a_n(mar)) := mdr; -- escritura
WHEN "0011" => -- SUM
ac := n_a_b((b_a_n(ac) + b_a_n(mdr)), 12); -- ac <-- <ac>+<mdr>
nz(1) := ac(11); -- n <-- <ac(11)>
IF ac = "000000000000" -- IF ac="000000000000"
THEN nz(0) := '1'; -- THEN z <-- '1'
ELSE nz(0) := '0'; -- ELSE z <-- '0'
END IF;
S8 10
Código VHDL del modelo completo (3)
WHEN "0100" => -- LDAI WHEN "1001" => -- JN
ac := "0000" & ir(7 DOWNTO 0); -- ac <-- <ir> IF nz(1) = '1' THEN
nz(1) := ac(11); -- n <-- <ac(11)> pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
IF ac = "000000000000" -- IF ac="000000000000" END IF;
THEN nz(0) := '1'; -- THEN z <-- '1' WHEN "1010" => -- JNN
ELSE nz(0) := '0'; -- ELSE z <-- '0' IF nz(1) = '0' THEN
END IF; pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
WHEN "0101" => -- SUMI END IF;
mdr := "0000" & ir(7 DOWNTO 0); -- mdr <-- <ir> WHEN OTHERS =>
ac := n_a_b((b_a_n(ac) + b_a_n(mdr)), 12); -- ac <-- <ac>+<mdr> END CASE;
nz(1) := ac(11); -- n <-- <ac(11)> -- visualiza pc, ac y nz
IF ac = "000000000000" -- IF ac="00000000000" WRITE(l,cpc);
THEN nz(0) := '1'; -- THEN z <-- '1' WRITE(l, pc);
ELSE nz(0) := '0'; -- ELSE z <-- '0' WRITE(l,cac);
END IF; WRITE(l, ac);
WHEN "0110" => -- NOR WRITE(l,cnz);
mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir> WRITE(l,nz);
mdr := mem(b_a_n(mar)); -- lectura WRITELINE(OUTPUT,l);
ac := ac NOR mdr; -- ac <-- <mdr> END LOOP;
nz(1) := ac(11); -- n <-- <ac(11)> -- visualiza las primeras posiciones de memoria
IF ac = "000000000000" -- IF ac="000000000000" FOR i IN 0 TO 30 LOOP --
THEN nz(0) := '1'; -- THEN z <-- '1' WRITE(l,i); --
ELSE nz(0) := '0'; -- ELSE z <-- '0' WRITE(l, c); --
END IF; WRITE(l, mem(i)); --
WHEN "0111" => -- JZ WRITELINE(OUTPUT, l); --
IF nz(0) = '1' THEN END LOOP; --
pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir> END IF;
END IF; END PROCESS;
WHEN "1000" => -- JNZ END comportamiento;
IF nz(0) = '0' THEN
pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
END IF;
-- STOP
stop := '1';
S8 11
Código VHDL del paquete utilidad)
PACKAGE utilidad IS
FUNCTION b_a_n (bits : IN bit_vector) RETURN natural;
FUNCTION n_a_b (nat, nb : IN NATURAL) RETURN bit_vector;
END utilidad;
El paquete contiene las funciones
b_a_n(bits : IN bit_vector) y PACKAGE BODY utilidad IS
n_a_b(nat, nb : IN NATURAL) FUNCTION b_a_n (bits : IN bit_vector) RETURN natural IS
que realizan la conversión de tipo VARIABLE result : natural := 0;
BIT_VECTOR a tipo NATURAL, BEGIN
y de tipo NATURAL a tipo FOR indice IN bits'RANGE LOOP
BIT_VECTOR, respectivamente.
result := result * 2 + bit'POS(bits(indice));
El segundo argumento de esta última END LOOP;
función (nb) determina el número RETURN result;
de bits del resultado. END b_a_n;
FUNCTION n_a_b (nat, nb : IN NATURAL) RETURN bit_vector IS
VARIABLE nat_var : bit_vector(nb - 1 DOWNTO 0);
VARIABLE temp1, temp2 : NATURAL := 0;
BEGIN
temp1 := nat;
FOR i IN nb-1 DOWNTO 0 LOOP
temp2 := temp1/(2**i);
temp1 := temp1 mod (2**i);
IF ( temp2 = 1 ) THEN nat_var(i) := '1';
ELSE nat_var(i) := '0';
END IF;
END LOOP;
RETURN nat_var;
END n_a_b;
END utilidad;
S8 12
Resultados de la simulación
Registros
# <PC> = 000000000001 <AC> = 001000010011 <NZ> = 00 # <PC> = 000000000001 <AC> = 001000011000 <NZ> = 00
# <PC> = 000000000010 <AC> = 001000010100 <NZ> = 00 # <PC> = 000000000010 <AC> = 001000011001 <NZ> = 00
# <PC> = 000000000011 <AC> = 001000010100 <NZ> = 00 # <PC> = 000000000011 <AC> = 001000011001 <NZ> = 00
# <PC> = 000000000100 <AC> = 000000010100 <NZ> = 00 # <PC> = 000000000100 <AC> = 000000011001 <NZ> = 00
# <PC> = 000000000101
# <PC> = 000000000110
<AC> = 000000010100
<AC> = 000000010101
<NZ> = 00
<NZ> = 00
# <PC> = 000000000101
# <PC> = 000000000110
<AC> = 000000011001
<AC> = 000000011010
<NZ> = 00
<NZ> = 00 Memoria
# <PC> = 000000000111 <AC> = 000000010101 <NZ> = 00 # <PC> = 000000000111 <AC> = 000000011010 <NZ> = 00
# <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00
# <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10 # <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10
# 00 = 000100000100
# <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # 01 = 010100000001
# <PC> = 000000001011 <AC> = 111111110111 <NZ> = 10 # <PC> = 000000001011 <AC> = 111111111100 <NZ> = 10
# <PC> = 000000000000 <AC> = 111111110111 <NZ> = 10 # <PC> = 000000000000 <AC> = 111111111100 <NZ> = 10 # 02 = 001000000100
# <PC> = 000000000001 <AC> = 001000010100 <NZ> = 00 # <PC> = 000000000001 <AC> = 001000011001 <NZ> = 00
# <PC> = 000000000010 <AC> = 001000010101 <NZ> = 00 # <PC> = 000000000010 <AC> = 001000011010 <NZ> = 00
# 03 = 000100001110
# <PC> = 000000000011 <AC> = 001000010101 <NZ> = 00 # <PC> = 000000000011 <AC> = 001000011010 <NZ> = 00 # 04 = 001000011101
# <PC> = 000000000100 <AC> = 000000010101 <NZ> = 00 # <PC> = 000000000100 <AC> = 000000011010 <NZ> = 00
# <PC> = 000000000101 <AC> = 000000010101 <NZ> = 00 # <PC> = 000000000101 <AC> = 000000011010 <NZ> = 00 # 05 = 010100000001
# <PC> = 000000000110
# <PC> = 000000000111
<AC> = 000000010110
<AC> = 000000010110
<NZ> = 00
<NZ> = 00
# <PC> = 000000000110
# <PC> = 000000000111
<AC> = 000000011011
<AC> = 000000011011
<NZ> = 00
<NZ> = 00
# 06 = 001000001110
# <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # 07 = 000100001101
# <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10 # <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10
# <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # 08 = 011000001101
# <PC> = 000000001011
# <PC> = 000000000000
<AC> = 111111111000
<AC> = 111111111000
<NZ> = 10
<NZ> = 10
# <PC> = 000000001011
# <PC> = 000000000000
<AC> = 111111111101
<AC> = 111111111101
<NZ> = 10
<NZ> = 10
# 09 = 010100000001
# <PC> = 000000000001 <AC> = 001000010101 <NZ> = 00 # <PC> = 000000000001 <AC> = 001000011010 <NZ> = 00 # 10 = 001100001110
# <PC> = 000000000010 <AC> = 001000010110 <NZ> = 00 # <PC> = 000000000010 <AC> = 001000011011 <NZ> = 00
# <PC> = 000000000011 <AC> = 001000010110 <NZ> = 00 # <PC> = 000000000011 <AC> = 001000011011 <NZ> = 00 # 11 = 100000000000
# <PC> = 000000000100
# <PC> = 000000000101
<AC> = 000000010110
<AC> = 000000010110
<NZ> = 00
<NZ> = 00
# <PC> = 000000000100
# <PC> = 000000000101
<AC> = 000000011011
<AC> = 000000011011
<NZ> = 00
<NZ> = 00
# 12 = 000000000000
# <PC> = 000000000110 <AC> = 000000010111 <NZ> = 00 # <PC> = 000000000110 <AC> = 000000011100 <NZ> = 00 # 13 = 000000011110
# <PC> = 000000000111 <AC> = 000000010111 <NZ> = 00 # <PC> = 000000000111 <AC> = 000000011100 <NZ> = 00
# <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # 14 = 000000011110
# <PC> = 000000001001
# <PC> = 000000001010
<AC> = 111111100001
<AC> = 111111100010
<NZ> = 10
<NZ> = 10
# <PC> = 000000001001
# <PC> = 000000001010
<AC> = 111111100001
<AC> = 111111100010
<NZ> = 10
<NZ> = 10
# 15 = 000000000000
# <PC> = 000000001011 <AC> = 111111111001 <NZ> = 10 # <PC> = 000000001011 <AC> = 111111111110 <NZ> = 10 # 16 = 000000000000
# <PC> = 000000000000 <AC> = 111111111001 <NZ> = 10 # <PC> = 000000000000 <AC> = 111111111110 <NZ> = 10
# <PC> = 000000000001 <AC> = 001000010110 <NZ> = 00 # <PC> = 000000000001 <AC> = 001000011011 <NZ> = 00 # 17 = 000000000000
# <PC> = 000000000010
# <PC> = 000000000011
<AC> = 001000010111
<AC> = 001000010111
<NZ> = 00
<NZ> = 00
# <PC> = 000000000010
# <PC> = 000000000011
<AC> = 001000011100
<AC> = 001000011100
<NZ> = 00
<NZ> = 00
# 18 = 000000000000
# <PC> = 000000000100 <AC> = 000000010111 <NZ> = 00 # <PC> = 000000000100 <AC> = 000000011100 <NZ> = 00 # 19 = 000000000000
# <PC> = 000000000101 <AC> = 000000010111 <NZ> = 00 # <PC> = 000000000101 <AC> = 000000011100 <NZ> = 00
# <PC> = 000000000110 <AC> = 000000011000 <NZ> = 00 # <PC> = 000000000110 <AC> = 000000011101 <NZ> = 00 # 20 = 000000010100
# <PC> = 000000000111
# <PC> = 000000001000
<AC> = 000000011000
<AC> = 000000011110
<NZ> = 00
<NZ> = 00
# <PC> = 000000000111
# <PC> = 000000001000
<AC> = 000000011101
<AC> = 000000011110
<NZ> = 00
<NZ> = 00
# 21 = 000000010101
# <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10 # <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10 # 22 = 000000010110
# <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10
# <PC> = 000000001011 <AC> = 111111111010 <NZ> = 10 # <PC> = 000000001011 <AC> = 111111111111 <NZ> = 10 # 23 = 000000010111
# <PC> = 000000000000 <AC> = 111111111010 <NZ> = 10 # <PC> = 000000000000 <AC> = 111111111111 <NZ> = 10 # 24 = 000000011000
# <PC> = 000000000001 <AC> = 001000010111 <NZ> = 00 # <PC> = 000000000001 <AC> = 001000011100 <NZ> = 00
# <PC> = 000000000010 <AC> = 001000011000 <NZ> = 00 # <PC> = 000000000010 <AC> = 001000011101 <NZ> = 00 # 25 = 000000011001
# <PC> = 000000000011 <AC> = 001000011000 <NZ> = 00 # <PC> = 000000000011 <AC> = 001000011101 <NZ> = 00
# <PC> = 000000000100 <AC> = 000000011000 <NZ> = 00 # <PC> = 000000000100 <AC> = 000000011101 <NZ> = 00 # 26 = 000000011010
# <PC> = 000000000101 <AC> = 000000011000 <NZ> = 00 # <PC> = 000000000101 <AC> = 000000011101 <NZ> = 00 # 27 = 000000011011
# <PC> = 000000000110 <AC> = 000000011001 <NZ> = 00 # <PC> = 000000000110 <AC> = 000000011110 <NZ> = 00
# <PC> = 000000000111 <AC> = 000000011001 <NZ> = 00 # <PC> = 000000000111 <AC> = 000000011110 <NZ> = 00 # 28 = 000000011100
# <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00 # <PC> = 000000001000 <AC> = 000000011110 <NZ> = 00
# <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10 # <PC> = 000000001001 <AC> = 111111100001 <NZ> = 10
# 29 = 000000011101
# <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10 # <PC> = 000000001010 <AC> = 111111100010 <NZ> = 10
# <PC> = 000000001011 <AC> = 111111111011 <NZ> = 10 # <PC> = 000000001011 <AC> = 000000000000 <NZ> = 01
S8 # <PC> = 000000000000 <AC> = 111111111011 <NZ> = 10 # <PC> = 000000001100 <AC> = 000000000000 <NZ> = 01
13
Modelo CPU-Memoria (1)
• En este segundo modelo descompondremos el computador en sus dos unidades básica:
UCP y la Memoria.
• Para cada unidad diseñaremos una entidad que describirá su comportamiento funcional y temporal.
• El reloj del sistema también lo modelaremos como una entidad
start
Reloj
stop clk
lec MEMORIA
dis
esc
CPU s_dat e_dat dir

12 12 12
S8 14
Modelo VHDL del Reloj

• Consta de dos entradas de control: ENTITY reloj IS
GENERIC(tl : TIME := 20 ns; th : TIME := 5 ns);
•start para iniciar la generación de pulsos PORT(start, stop : IN bit; clock : OUT bit);
END reloj;
•stop para detenerla.
ARCHITECTURE comportamiento OF reloj IS
• Ambas se activan con flancos positivos de sus valores. SIGNAL clk : bit := '0';
BEGIN
• El tiempo de permanencia en alta y baja de la señal de PROCESS(start, stop, clk)
salida clock viene determinado por los parámetros VARIABLE clke : bit := '0';
BEGIN
genéricos th y tl respectivamente
IF (start = '1' and NOT start'STABLE) THEN
clke := '1';
clk <= TRANSPORT '1' AFTER 0 ns;
clk <= TRANSPORT '0' AFTER th;
start Reloj
END IF;
IF (stop = '1' and NOT stop'STABLE) THEN
clke := '0';
stop clock
END IF;
IF (clk = '0' and NOT clk'STABLE and clke = '1') THEN
clk <= TRANSPORT '1' AFTER tl;
th tl clk <= TRANSPORT '0' AFTER tl+th;
END IF;
clock
clock <= clk;
END PROCESS;
start
END comportamiento;
stop
S8 15
Modelo VHDL de la Memoria (1)
Memoria asíncrona con buses independientes de entrada y salida de datos: bus_dat_sal y bus_dat_ent..
El control se realiza con tres señales binarias: lec, esc y dis.
La primera para leer, la segunda para escribir, y la tercera para señalar la finalización de la operación realizada.
Los buses de datos y el de direcciones (bus_dir) son todos de 12 bits de longitud
Las operaciones de lectura y escritura se realizan asíncronamente con un protocolo de señales tipo hand-shaking
bus_dir
lec
MEMORIA lec
dis
dato valido
esc bus_dat_sal
dis
12 12 12 lectura de memoria
bus_dat_sal bus_dat_ent bus_dir
bus_dir
ENTITY memoria IS
PORT (bus_dat_sal : OUT bit_vector(11 DOWNTO 0); esc
bus_dat_ent : IN bit_vector(11 DOWNTO 0); dato valido
bus_dir : IN bit_vector(11 DOWNTO 0); bus_dat_ent
lec, esc : IN bit;
dis : OUT bit); dis
END memoria;
escritura en memoria
S8 16
Modelo VHDL de la Memoria (2)
ARCHITECTURE comportamiento OF memoria IS BEGIN

BEGIN bus_dat_sal <= "000000000000" AFTER 5 ns;
PROCESS dis <= '0'AFTER 5 ns;
TYPE array_memoria IS WAIT UNTIL (lec = '1') OR (esc = '1');
ARRAY (NATURAL RANGE 0 TO 255) OF bit_vector(11 direc := b_a_n(bus_dir);
DOWNTO 0); -- visualiza las primeras posiciones de memoria
VARIABLE mem : array_memoria := IF (esc = '1') AND (lec = '1') THEN --
("000100000100", -- 0 LDA (STA índice) FOR i IN 0 TO 30 LOOP --
"010100000001", -- 1 SUMI 1 WRITE(l,i); --
"001000000100", -- 2 STA (STA índice+1) WRITE(l, c); --
"000100001110", -- 3 LDA índice WRITE(l, mem(i));
"001000010011", -- 4 STA índice --
"010100000001", -- 5 SUMI 1 WRITELINE(OUTPUT, l); --
"001000001110", -- 6 STA índice END LOOP;
"000100001101", -- 7 LDA limite --
"011000001101", -- 8 NOR limite -- cuando se activan simultnemente lec y esc
"010100000001", -- 9 SUMI 1 ELSIF esc = '1' THEN
"001100001110", -- 10 SUM índice mem(direc) := bus_dat_ent;
"100000000000", -- 11 JNZ 0 dis <= '1' AFTER 20 ns;
"000000000000", -- 12 HALT WAIT UNTIL esc = '0';
"000000011110", -- 13 limite ELSE
"000000010100", -- 14 índice bus_dat_sal <= mem(direc) AFTER 15 ns;
OTHERS => "000000000000"); dis <= '1' AFTER 20 ns;
SUBTYPE dir IS NATURAL RANGE 0 TO 255; WAIT UNTIL lec = '0';
VARIABLE direc : dir; END IF;
VARIABLE l : LINE; END PROCESS;
CONSTANT c : STRING := " = "; END comportamiento;
S8 17
Modelo VHDL de la Unidad Central de Proceso
Su periferia dispondrá de los buses de datos direcciones y control necesarios para comunicarse con la memoria.
Se comunicará con el reloj a través de dos señales binarias:
• clk para recibir la señal de reloj
• stop para detener la generación de pulsos cuando se ejecute la instrucción de parada HALT
stop clk
lec
dis
esc
CPU
12
bus_ent
12
bus_sal
12
bus_dir
ENTITY cpu IS
PORT (bus_sal : OUT bit_vector(11 DOWNTO 0);
bus_ent : IN bit_vector(11 DOWNTO 0);
bus_dir : OUT bit_vector(11 DOWNTO 0);
lec, esc, stop : OUT bit;
dis, clk : IN bit);
END cpu;
S8 18
Procedimiento de lectura Procedimiento de escritura
PROCEDURE lectura IS PROCEDURE escritura IS

BEGIN BEGIN
WAIT UNTIL (clk'EVENT AND clk = '0'); WAIT UNTIL (clk'EVENT AND clk = '0');
bus_dir <= mar; bus_dir <= mar;
WAIT UNTIL (clk'EVENT AND clk = '0'); bus_sal <= mdr;
lec <= '1'; WAIT UNTIL (clk'EVENT AND clk = '0');
WAIT UNTIL dis = '1'; esc <= '1';
WAIT UNTIL (clk'EVENT AND clk = '0'); WAIT UNTIL dis = '1';
mdr := bus_ent; WAIT UNTIL (clk'EVENT AND clk = '0');
WAIT UNTIL (clk'EVENT AND clk = '0'); esc <= '0';
lec <= '0'; END escritura;
END lectura;
clock
clock
bus_dir
bus_dir
esc
lec
dis
dis
bus_sal
bus_ent
S8 19
USE WORK.utilidad.ALL;
ENTITY cpu IS
PORT (bus_sal : OUT bit_vector(11 DOWNTO 0);
Código VHDL completo de la Unidad
bus_ent : IN bit_vector(11 DOWNTO 0); Central de Proceso (1)
bus_dir : OUT bit_vector(11 DOWNTO 0);
lec, esc, stop : OUT bit; BEGIN
dis, clk : IN bit); mar := pc; -- mar <-- <pc>
END cpu; lectura; -- lectura
ARCHITECTURE comportamiento OF cpu IS ir := mdr; -- ir <-- <mdr>
BEGIN pc := n_a_b((b_a_n(pc) + 1), 12); -- pc <-- <pc> + 1
PROCESS WAIT UNTIL (clk'EVENT AND clk = '0'); -- decodificacion
VARIABLE mdr, mar, pc, ir, ac : bit_vector(11 DOWNTO 0);
VARIABLE nz : bit_vector(1 DOWNTO 0);
PROCEDURE lectura IS
BEGIN
WAIT UNTIL (clk'EVENT AND clk = '0');
bus_dir <= mar;
lec <= '1';
WAIT UNTIL dis = '1';
mdr := bus_ent;
lec <= '0';
END lectura;
PROCEDURE escritura IS
BEGIN
bus_dir <= mar;
bus_sal <= mdr;
esc <= '1';
WAIT UNTIL dis = '1';
esc <= '0';
END escritura;
S8 20
CASE ir(11 DOWNTO 8) IS
WHEN "0001" => -- LDA
mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir> Código VHDL completo de la Unidad
lectura; -- lectura
ac := mdr; -- ac <-- <mdr> Central de Proceso (2)
nz(1) := ac(11); -- n <-- <ac(11)>
IF ac = "000000000000" -- IF ac="000000000000"
THEN nz(0) := '1'; -- THEN z <-- '1'
ELSE nz(0) := '0'; -- ELSE z <-- '0' WHEN "0110" => -- NOR
END IF; mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir>
WHEN "0010" => -- STA lectura; -- lectura
mdr := ac; -- mdr <-- <ac> ac := ac NOR mdr; -- ac <-- <mdr>
mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir> nz(1) := ac(11); -- n <-- <ac(11)>
escritura; -- escritura IF ac = "000000000000" -- IF ac="000000000000"
WHEN "0011" => -- SUM THEN nz(0) := '1'; -- THEN z <-- '1'
mar := "0000" & ir(7 DOWNTO 0); -- mar <-- <ir> ELSE nz(0) := '0'; -- ELSE z <-- '0'
lectura; -- lectura END IF
ac := n_a_b((b_a_n(ac) + b_a_n(mdr)), 12); -- ac <-- <ac>+<mdr> WHEN "0111" => -- JZ
nz(1) := ac(11); -- n <-- <ac(11)> IF nz(0) = '1' THEN
IF ac = "000000000000" -- IF ac="000000000000" pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
THEN nz(0) := '1'; -- THEN z <-- '1' END IF;
ELSE nz(0) := '0'; -- ELSE z <-- '0' WHEN "1000" => -- JNZ
END IF; IF nz(0) = '0' THEN
WHEN "0100" => -- LDAI pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
ac := "0000" & ir(7 DOWNTO 0); -- ac <-- <ir> END IF;
nz(1) := ac(11); -- n <-- <ac(11)> WHEN "1001" => -- JN
IF ac = "000000000000" -- IF ac="000000000000" IF nz(1) = '1' THEN
THEN nz(0) := '1'; -- THEN z <-- '1' pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
ELSE nz(0) := '0'; -- ELSE z <-- '0' END IF;
END IF; WHEN "1010" => -- JNN
WHEN "0101" => -- SUMI IF nz(1) = '0' THEN
mdr := "0000" & ir(7 DOWNTO 0); -- mdr <-- <ir> pc := "0000" & ir(7 DOWNTO 0); -- pc <-- <ir>
ac := n_a_b((b_a_n(ac) + b_a_n(mdr)), 12); -- ac <-- <ac>+<mdr> END IF;
nz(1) := ac(11); -- n <-- <ac(11)> WHEN OTHERS =>
IF ac = "000000000000" -- IF ac="000000000000" lec <= '1';
THEN nz(0) := '1'; esc <= '1'; -- volcado memoria
-- THEN z <-- '1' stop <= '1', '0' AFTER 5 ns; -- parada
ELSE nz(0) := '0'; END CASE;
-- ELSE z <-- '0' END PROCESS;
END IF; END comportamiento;
S8 21
Modelo Estructural CPU-Memoria
ENTITY comput IS PORT (start : IN bit);

END comput;
ARCHITECTURE estructura OF comput IS
Rel oj COMPONENT cpu
st ar t PORT (bus_sal : OUT bit_vector(11 DOWNTO 0);
st op cl k
bus_ent : IN bit_vector(11 DOWNTO 0);
st op cl k ME MOR I A bus_dir : OUT bit_vector(11 DOWNTO 0);
la t
n lec, esc, stop : OUT bit;
st op cl k e
lec s _ dis, clk : IN bit);
lec lec _ t t ri
a a d END COMPONENT;
di s d
di s di s d_ _
s
_
s COMPONENT memoria
esc s u u
esc esc u b b b PORT (bus_dat_sal : OUT bit_vector(11 DOWNTO 0);
bus_dat_ent : IN bit_vector(11 DOWNTO 0);
UCP bus_dir : IN bit_vector(11 DOWNTO 0);
lec, esc : IN bit;
12 12 12 dis : OUT bit);
ent END COMPONENT;
bu s _en t
sal COMPONENT reloj
bu s_sal GENERIC(tl : TIME := 20 ns; th : TIME := 5 ns);
di r PORT(start, stop : IN bit;
bu s_di r
clock : OUT bit);
END COMPONENT;
SIGNAL sal, ent, dir : bit_vector(11 DOWNTO 0);
SIGNAL lec, dis, esc, stop, clk : bit;
BEGIN
clock : reloj GENERIC MAP(20 ns, 5 ns)
PORT MAP(start, stop, clk);
memor : memoria PORT MAP(ent, sal, dir, lec, esc, dis);
unice : cpu PORT MAP(sal, ent, dir, lec, esc, stop, dis, clk);
END estructura;
S8 22
Resultados de la simulación
ns delta start sal ent dir lec dis esc stop clk
0 +0 0 000000000000 000000000000 000000000000 0 0 0 0 0
5 +0 1 000000000000 000000000000 000000000000 0 0 0 0 0
5 +2 1 000000000000 000000000000 000000000000 0 0 0 0 1
10 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
20 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
LDAI 3
25 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
35 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
40 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
40 +2 1 000000000000 000000000000 000000000000 1 0 0 0 0
50 +1 1 000000000000 000000000000 000000000000 1 0 0 0 1
55 +0 1 000000000000 010000000011 000000000000 1 0 0 0 1
55 +1 1 000000000000 010000000011 000000000000 1 0 0 0 0
60 +0 1 000000000000 010000000011 000000000000 1 1 0 0 0
65 +1 1 000000000000 010000000011 000000000000 1 1 0 0 1
70 +1 1 000000000000 010000000011 000000000000 1 1 0 0 0
80 +1 1 000000000000 010000000011 000000000000 1 1 0 0 1
85 +1 1 000000000000 010000000011 000000000000 1 1 0 0 0
85 +2 1 000000000000 010000000011 000000000000 0 1 0 0 0
90 +0 1 000000000000 000000000000 000000000000 0 0 0 0 0
95 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
100 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
110 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
115 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
125 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
130 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
140 +1 1 000000000000 000000000000 000000000000 0 0 0 0 1
145 +1 1 000000000000 000000000000 000000000000 0 0 0 0 0
SUM 4
145 +2 1 000000000000 000000000000 000000000001 0 0 0 0 0
155 +1 1 000000000000 000000000000 000000000001 0 0 0 0 1
160 +1 1 000000000000 000000000000 000000000001 0 0 0 0 0
160 +2 1 000000000000 000000000000 000000000001 1 0 0 0 0
170 +1 1 000000000000 000000000000 000000000001 1 0 0 0 1
S8 175 +0 1 000000000000 001100000100 000000000001 1 0 0 0 1 23
Modelo Estructural de la Ruta de Datos (1)
lectu r a
di spon i bl e
escr i tu r a
bu s1
bus dat os en tr ada
En este modelo vamos
sel 1
M UX 0
a incorporar la estructura
interna de la ruta de datos, Memor i a
es decir, sustituiremos el e_mdr
s_mdr M DR bu s2
modelo de comportamiento
algoritmico de esta unidad bus datos sal i da
por otro estructural e_mar
compuesto por un conjunto s_mar M AR
de registros y unidades Un idad bus di r ecciones
funcionales interconectados de
Cont rol e_pc
por una red de buses y/o s_pc PC
multiplexores
e_ir
s_ir IR
co
e_ac
s_ac AC
op0 a b
op1
op2 U AL
e_nz
s_nz N Z
n
z
S8 24
Multiplexor
d0 d1
12 12
1 0
sel MUX
12
USE WORK.std_logic_1164.ALL;
ENTITY mux IS
PORT (d0, d1 : IN std_logic_vector(11 DOWNTO 0);
z : OUT std_logic_vector(11 DOWNTO 0);
sel : IN std_ulogic);
END mux;
ARCHITECTURE comportamiento OF mux IS

BEGIN
PROCESS(d0, d1, sel)
BEGIN
IF sel = '1'
THEN
z <= d1 AFTER 5 ns;
ELSE
z <= d0 AFTER 5 ns;
END IF;
END PROCESS;
END comportamiento;
S8 25
valor del dato cargado
entrada Registros de 12 bits (mdr, mar, pc, ac)
entrada reloj
e_r e_r registro s_r

s_r
salida dato válido
reloj salida
(a) (b)
USE STD.TEXTIO.ALL;
ENTITY reg12 IS
GENERIC ( nombre : STRING := "registro general");
PORT ( ed : IN std_logic_vector(11 DOWNTO 0);
clk, reset, e_r, s_r : IN std_ulogic;
sd : OUT std_logic_vector(11 DOWNTO 0));
END reg12;
ARCHITECTURE comportamiento OF reg12 IS
BEGIN
ed PROCESS
VARIABLE r, ar : std_logic_vector(11 DOWNTO 0) := "000000000000";
reset 12 VARIABLE l : LINE;
e_r BEGIN
REG12 clk
s_r WAIT UNTIL (rising_edge(clk) OR s_r'EVENT OR reset'EVENT);
12
ar := r;
IF falling_edge(reset) THEN r := "000000000000"; END IF;
sd IF rising_edge(clk) THEN
IF e_r = '1' THEN r := ed; END IF;
END IF;
IF s_r = '1' THEN sd <= r; ELSE sd <= "ZZZZZZZZZZZZ"; END IF;
--
IF r /= ar THEN -- Código
WRITE(l, nombre); -- añadido
WRITE(l,To_bitvector(r)); -- para
WRITELINE(OUTPUT,l); -- depuración
END IF; -- de la RD --
END PROCESS;
END comportamiento;
S8 26
USE STD.TEXTIO.ALL;
Registro de Instrucciones USE WORK.std_logic_1164.ALL;
ENTITY regir IS
ed GENERIC (nombre : STRING := "registro instrucción");
reset 12
e_r sdb : OUT std_logic_vector(7 DOWNTO 0);
REGIR clk sdc : OUT std_logic_vector(3 DOWNTO 0));
s_r
4 8 END regir;
ARCHITECTURE comportamiento OF regir IS
sdc sdb BEGIN
PROCESS
VARIABLE r, ar : std_logic_vector(11 DOWNTO 0) := "000000000000";
VARIABLE l : LINE;
BEGIN
WAIT UNTIL (rising_edge(clk) OR s_r'EVENT OR reset'EVENT);
ar := r;
IF falling_edge(reset) THEN r := "000000000000"; END IF;
IF rising_edge(clk) THEN
IF e_r = '1' THEN r := ed; END IF;
END IF;
IF s_r = '1'
THEN
sdb <= r(7 DOWNTO 0);
ELSE
sdb <= "ZZZZZZZZ";
END IF;
sdc <= r(11 DOWNTO 8);
IF r /= ar THEN
WRITE(l, nombre);
WRITE(l,To_bitvector(r));
END IF;
END PROCESS;
END comportamiento;
S8 27
USE STD.TEXTIO.ALL;
Registro de Estado USE WORK.std_logic_1164.ALL;
ENTITY reg2 IS
PORT ( e0, e1, clk, reset, e_r, s_r : IN std_ulogic;
s0, s1 : OUT std_ulogic);
e0 e1 END reg2;
ARCHITECTURE comportamiento OF reg2 IS
reset BEGIN
PROCESS
VARIABLE r0, r1, ar0, ar1 : std_ulogic := '0';
e_r clk VARIABLE l : LINE;
s_r REG2 CONSTANT creg2 : STRING := "<NZ> = ";
BEGIN
WAIT UNTIL (rising_edge(clk) OR s_r'EVENT OR reset'EVENT);
s0 s1 ar0 := r0; ar1 := r1;
IF falling_edge(reset) THEN r0 := '0'; r1 := '0'; END IF;
IF rising_edge(clk) THEN
IF e_r = '1' THEN r0 := e0; r1 := e1; END IF;
END IF;
IF s_r = '1'
THEN
s0 <= r0 AFTER 10 ns;
s1 <= r1 AFTER 10 ns;
ELSE
s0 <= 'Z' AFTER 10 ns;
s1 <= 'Z' AFTER 10 ns;
END IF;
IF (r0 /= ar0) OR (r1 /= ar1) THEN
WRITE(l, creg2);
WRITE(l,To_bit(r1, '0'));WRITE(l,To_bit(r0,'0'));
END IF;
END PROCESS;
END comportamiento;
S8 28
Unidad Aritmético-Lógica (ual) USE WORK.utilidad.ALL;
a USE WORK.std_logic_1164.ALL;
b ENTITY ual IS
12 12 PORT( a, b : IN std_logic_vector(11 DOWNTO 0);
op0, op1, op2 : IN std_ulogic;
op2 s : OUT std_logic_vector(11 DOWNTO 0);
op1 z n, z : OUT std_ulogic);
op0 UAL n END ual;
12 ARCHITECTURE comportamiento OF ual IS
BEGIN
s PROCESS(a,b,op0, op1,op2)
op2 op1 op0 s VARIABLE as : std_logic_vector(11 DOWNTO 0);
VARIABLE op :bit_vector(2 DOWNTO 0);
0 0 0 "000000000000"
BEGIN
0 0 1 "0000" & b(7 DOWNTO 0) op := To_bit(op2, '0')&To_bit(op1, '0')&To_bit(op0,'0');
CASE op IS
0 1 0 a NOR b WHEN "000" => as := "000000000000";
0 1 1 b WHEN "001" => as := "0000" & b(7 DOWNTO 0);
WHEN "010" =>
1 0 0 b+1 as := To_StdLogicVector(To_StdULogicVector(a) NOR
1 0 1 a To_StdULogicVector(b)) ;
WHEN "011" => as := b;
1 1 0 a+b WHEN "100" =>
as := To_StdLogicVector(n_a_b((b_a_n(To_bitvector(b)) + 1), 12));
1 1 1 no opera WHEN "101" => as := a;
WHEN "110" =>
Para compatibilizar tipos, se han utilizado las siguientes as := To_StdLogicVector(n_a_b(( b_a_n(To_bitvector(a)) +
funciones de conversión de tipos del paquete b_a_n(To_bitvector(b))), 12));
STD_LOGC_1164: WHEN OTHERS => NULL;
END CASE;
- To_bit ( , ) : s <= as AFTER 5 ns;
std_ulogic a bit IF as(11)= '1‘ THEN n <= '1' AFTER 5 ns; ELSE n <= '0' AFTER 5 ns;
- To_StdLogicVector ( ) : END IF;
bit_vector Æstd_logic_vector IF as = "000000000000“ THEN z <= '1' AFTER 5 ns; ELSE z <= '0'
- To_StdULogicVector ( ) : AFTER 5 ns;
std_logic_vector Æ std_ulogic_vector END IF;
- To_bitvector( ) : END PROCESS;
std_logic_vector Æ bit_vector END comportamiento;
S8 29
ARCHITECTURE estructura OF ruta IS
Conexión estructural COMPONENT mux
PORT ( d0, d1 : IN std_logic_vector(11 DOWNTO 0);
de la ruta de datos z : OUT std_logic_vector(11 DOWNTO 0);
reset clk sel : IN std_ulogic);
bus de datos de entrada
END COMPONENT;
bus1 bus2
sel 1 0
COMPONENT reg12
MUX GENERIC (nombre : STRING);
mm
e_mdr sd : OUT std_logic_vector(11 DOWNTO 0) );
s_mdr MDR END COMPONENT;
bus de datos de salida COMPONENT regir
e_mar
GENERIC ( nombre : STRING);
s_mar MAR
bus de direcciones clk, reset, e_r, s_r : IN std_ulogic;
sdb : OUT std_logic_vector(7 DOWNTO 0);
e_pc sdc : OUT std_logic_vector(11 DOWNTO 8));
s_pc PC END COMPONENT;
COMPONENT reg2
e_ir PORT ( e0, e1 : IN std_logic;
s_ir IR clk, reset, e_r, s_r : IN std_ulogic;
s0, s1 : OUT std_logic );
co END COMPONENT;
4 COMPONENT ual
e_ac PORT( a, b : IN std_logic_vector(11 DOWNTO 0);
s_ac AC op0, op1, op2 : IN std_ulogic;
au s : OUT std_logic_vector(11 DOWNTO 0);
op0 a b n, z : std_logic);
op1
op2 UAL END COMPONENT;
SIGNAL bus1, bus2, mm, au : std_logic_vector(11 DOWNTO 0);
sn sz
e_nz SIGNAL sn, sz : std_logic;
s_nz CONSTANT rmdr : STRING := "<MDR> = ";
NZ
CONSTANT rmar : STRING := "<MAR> = ";
n
z CONSTANT rpc : STRING := "<PC> = ";
CONSTANT rac : STRING := "<AC> = ";
CONSTANT rir : STRING := "<IR> = ";
USE WORK.std_logic_1164.ALL; BEGIN
USE WORK.ALL; mu : mux PORT MAP(s_dat, bus1, mm, sel);
ENTITY ruta IS mdr : reg12 GENERIC MAP(rmdr) PORT MAP(mm, clk, reset, e_mdr, s_mdr, bus2);
PORT ( e_dat : OUT std_logic_vector(11 DOWNTO 0); mar : reg12 GENERIC MAP(rmar) PORT MAP(bus1, clk, reset, e_mar, s_mar, dir);
s_dat : IN std_logic_vector(11 DOWNTO 0); pc : reg12 GENERIC MAP(rpc) PORT MAP(bus1, clk, reset, e_pc, s_pc, bus2);
dir : OUT std_logic_vector(11 DOWNTO 0); ir : regir GENERIC MAP (rir)
clk, reset, sel, e_mdr, s_mdr, e_mar, s_mar, e_pc, s_pc, PORT MAP(bus1, clk, reset, e_ir, s_ir, bus2(7 DOWNTO 0), co);
e_ir, s_ir, e_ac, s_ac, e_nz, s_nz : IN std_ulogic; ac : reg12 GENERIC MAP(rac) PORT MAP(bus1, clk, reset, e_ac, s_ac, au);
op0, op1, op2 : IN std_ulogic; ua : ual PORT MAP(au,bus2, op0, op1, op2, bus1, sn, sz);
n, z : OUT std_logic; nz : reg2 PORT MAP(sz, sn, clk, reset, e_nz, s_nz, n, z);
co : OUT std_logic_vector(3 DOWNTO 0)); e_dat <= bus2;
END ruta; END estructura;
S8 30
Modelo de la Unidad de Control
• La Unidad de Control se encarga de generar todas las señales que gobiernan el flujo de información por la RD.
Fases de búsqueda y decodificación: se lee la instrucción de memoria, se transfiere a IR y se decodifica.
clk
lec
esc <PC> Æ MAR
stop
• s_pc (salir del PC)
sel
• op0 y op1 (paso transparente por b de la UAL)
e_mdr • e_mar (entrar en el MAR).
s_mdr
e_mar Lectura de la instrucción
s_mar
• s_mar (salir del MAR)
e_pc • lec (al comienzo del siguiente ciclo)
s_pc • dis, (disponibilidad del dato)
e_ir • e_mdr (cargar el dato leido en el registro MDR. )
s_ir • desactivación de s_mar y lec
e_ac <MDR> Æ RI
s_ac
op0 • s_mdr, op0, op1 y e_ri.
op1
<PC> + 1 Æ PC
op2 • s_pc, op2 y e_pc.
e_nz
s_nz Decodificación
• la UC generará las señales específicas que

dis gobiernan el flujo de información para la
n correspondiente instrucción
z
mar <--<pc> lectura ir <-- <mdr> pc <-- <pc>+1
búsqueda decodificación
S8 31
Cronogramas correspondientes a las instrucciones SUM y STA
clk clk
lec lec
esc esc
stop stop
sel sel
e_mdr e_mdr
s_mdr s_mdr
e_mar e_mar
s_mar s_mar
e_pc e_pc
s_pc s_pc
e_ir e_ir
s_ir s_ir
e_ac e_ac
s_ac s_ac
op0 op0
op1 op1
op2 op2
e_nz e_nz
s_nz s_nz
dis dis
n n
z z
SUM STA
S8 32
Cronogramas correspondientes a las instrucciones LDAI, JNZ y HALT.
clk clk clk

lec lec lec
esc esc esc
stop stop stop
sel sel sel
e_mdr e_mdr e_mdr
s_mdr s_mdr s_mdr
e_mar e_mar e_mar
s_mar s_mar s_mar
e_pc e_pc e_pc
s_pc s_pc s_pc
e_ir e_ir e_ir
s_ir s_ir s_ir
e_ac e_ac e_ac
s_ac s_ac s_ac
op0 op0 op0
op1 op1 op1
op2 op2 op2
e_nz e_nz e_nz
s_nz s_nz s_nz
dis dis dis
n n n
z z JNZ
z
LDAI HALT
S8 33
ciclo 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
clk
lec
Señales generadas por la UC esc
stop
a lo largo de la ejecución sel
e_mdr
delsiguiente programa: s_mdr
e_mar
s_mar
e_pc
Dir. Simbólico Binario s_pc
e_ir
0 LDAI 3 0100 00000011 s_ir
e_ac
1 SUM 4 0011 00000100 s_ac
op0
2 STA 5 0010 00000101 op1
3 HALT 0000 00000000 op2
e_nz
s_nz
dis
• El programa dura 39 ciclos n
z
LDAI 3 SUM 4
• La parada la origina la ejecución
de la instrucción HALT activando ciclo 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
la señal stop, que bloquea la clk
generación de pulsos de reloj lec

esc
stop
sel
e_mdr
s_mdr
e_mar
s_mar
e_pc
s_pc
e_ir
s_ir
e_ac
s_ac
op0
op1
op2
e_nz
s_nz
dis
n
z
STA 5 HALT
S8 34
PACKAGE std_logic_1164 IS
TYPE std_ulogic IS ( 'U', -- Uninitialized
'X', -- Forcing Unknown
Partedel paquete '0', -- Forcing 0
standard IEEE '1', -- Forcing 1
'Z', -- High Impedance
std_logic_1164 'W', -- Weak Unknown
'L', -- Weak 0
'H', -- Weak 1
'-' -- Don't care );
TYPE std_ulogic_vector IS ARRAY ( NATURAL RANGE <> ) OF std_ulogic;
-- resolution function
FUNCTION resolved ( s : std_ulogic_vector ) RETURN std_ulogic;
SUBTYPE std_logic IS resolved std_ulogic;
TYPE std_logic_vector IS ARRAY ( NATURAL RANGE <>) OF std_logic;
-- overloaded logical operators
FUNCTION "and" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "nand" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "or" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "nor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "xor" ( l : std_ulogic; r : std_ulogic ) RETURN UX01;
FUNCTION "not" ( l : std_ulogic ) RETURN UX01;
-- conversion functions
FUNCTION To_bit ( s : std_ulogic; xmap : BIT := '0') RETURN BIT;
FUNCTION To_bitvector ( s : std_logic_vector ; xmap : BIT := '0') RETURN BIT_VECTOR;
FUNCTION To_bitvector ( s : std_ulogic_vector; xmap : BIT := '0') RETURN BIT_VECTOR;
FUNCTION To_StdULogic ( b : BIT ) RETURN std_ulogic;
FUNCTION To_StdLogicVector ( b : BIT_VECTOR ) RETURN std_logic_vector;
FUNCTION To_StdLogicVector ( s : std_ulogic_vector ) RETURN std_logic_vector;
FUNCTION To_StdULogicVector ( b : BIT_VECTOR ) RETURN std_ulogic_vector;
FUNCTION To_StdULogicVector ( s : std_logic_vector ) RETURN std_ulogic_vector;
-- edge detection
FUNCTION rising_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
FUNCTION falling_edge (SIGNAL s : std_ulogic) RETURN BOOLEAN;
-------------------------------------------------------------------
END std_logic_1164;
S8 35
Definición de los tipos de control
PACKAGE tipos_control IS
TYPE senales_control IS (lec, esc, stop, sel, e_mdr, s_mdr, e_mar,
s_mar,e_pc, s_pc, e_ir, s_ir, e_ac, s_ac,
op0, op1, op2, e_nz, s_nz);
TYPE vector_senales_control IS ARRAY (natural RANGE <>) OF senales_control;
TYPE bus_control IS ARRAY (senales_control) OF std_ulogic;
FUNCTION ctrl (ent : vector_senales_control) RETURN bus_control;
FUNCTION ctrl (ent : senales_control) RETURN bus_control;
FUNCTION ctrl RETURN bus_control;
END tipos_control;
PACKAGE BODY tipos_control IS
FUNCTION ctrl(ent : vector_senales_control) RETURN bus_control IS
VARIABLE res : bus_control := (OTHERS => '0');
BEGIN
FOR i IN ent'RANGE LOOP res(ent(i)) := '1'; END LOOP;
RETURN res;
END ctrl;
FUNCTION ctrl(ent : senales_control) RETURN bus_control IS
BEGIN
res(ent) := '1';
RETURN res;
END ctrl;
FUNCTION ctrl RETURN bus_control IS
BEGIN
RETURN res;
END ctrl;
END tipos_control;
S8 36
Modelo de comportamiento de la Unidad de Control
disp
Declaración de entidad
N
Z realimentación USE WORK.std_logic_1164.ALL;
co USE WORK.tipos_control.ALL;
lec ENTITY u_control IS
esc PORT(disp, n, z : IN std_ulogic;
stop co : IN std_logic_vector(3 DOWNTO 0);
sel control : OUT bus_control;
e_mdr clk : IN std_ulogic);
s_mdr END u_control;
e_mar
Unidad s_mar
de e_pc
Control s_pc control
e_ir
s_ir • Todas las señales binarias de salida (tipo std_ulogic) las hemos
agrupado en un array de nombre control de tipo bus_control
e_ac (array de std_ulogic sobre un índice enumerado de nombres de señales).
s_ac
op0 • La señal de entrada co será la única resuelta de tipo std_logic_vector
op1 (tipo utilizado en la salida de los registros de la RD, en particular el IR,
op2 de donde procede co)
e_nz
• Las restantes entradas (disp, N, Z, y clk) serán todas del tipo std_ulogic.
s_nz
clk reloj
S8 37
Arquitectura: procedimientos auxiliares
clk
PROCEDURE m_orden (ordenes : IN vector_senales_control) IS
BEGIN
WAIT UNTIL falling_edge(clk); • órdenes de control
control <= ctrl(ordenes); •
•
END m_orden;
PROCEDURE lectura IS PROCEDURE escritura IS

BEGIN BEGIN
WAIT UNTIL falling_edge(clk); WAIT UNTIL falling_edge(clk);
control <= ctrl(s_mar & s_mar); control <= ctrl(s_mar & s_mdr);
WAIT UNTIL falling_edge(clk); WAIT UNTIL falling_edge(clk);
control <= ctrl(s_mar & lec); control <= ctrl(s_mar & s_mdr & esc);
WAIT UNTIL disp = '1'; WAIT UNTIL disp = '1';
WAIT UNTIL falling_edge(clk); END escritura
control <= ctrl(s_mar & lec & e_mdr);
END lectura;
clk
clk
s_mar
s_mar
esc
lec
s_mdr
e_mdr
disp
disp
S8 38
Modelo Estructural de la Ruta de Datos (16) m_orden(s_pc & op0 & op1 & e_mar); -- mar <-- <pc>
lectura; -- Lectura
m_orden(s_mdr & op0 & op1 & e_ir); -- ir <-- <mdr>
Arquitectura m_orden(s_pc & op2 & e_pc);

WAIT UNTIL falling_edge(clk);
-- pc <-- <pc> + 1
-- Decodificación
control <= ctrl;
CASE co IS
ARCHITECTURE comportamiento OF u_control IS BEGIN
WHEN "0001" => -- LDA
PROCESS
m_orden(s_ir & op0 & e_mar); -- mar <-- <ir>
PROCEDURE m_orden(ordenes : IN vector_senales_control) IS
lectura; -- Lectura
BEGIN
m_orden(s_mdr & op0 & op1 & e_ac); -- ac <-- <mdr>
WHEN "0010" => -- STA
control <= ctrl(ordenes);
m_orden(s_ac & op0 & op2 & sel & e_mdr); -- mdr <-- <ac>
END m_orden;
PROCEDURE lectura IS
escritura; -- Escritura
BEGIN
WHEN "0011" => -- SUM
control <= ctrl(s_mar & s_mar);
lectura; -- Lectura
m_orden(s_mdr & s_ac & op2 & op1 & e_ac & e_nz); -- ac <-- <ac>+<mdr>
control <= ctrl(s_mar & lec);
WHEN "0100" => -- LDAI
WAIT UNTIL disp = '1';
m_orden(s_ir & op0 & e_ac); -- ac <-- <ir>
WHEN "0101" => -- SUMI
control <= ctrl(s_mar & lec & e_mdr);
m_orden(s_ir & op0 & e_mdr); -- mdr <-- <ir>
END lectura;
m_orden(s_mdr & s_ac & op2 & op1 & e_ac & e_nz);-- ac <-- <ac>+<mdr>
PROCEDURE escritura IS
WHEN "0110" => -- NOR
BEGIN
lectura; -- lectura
control <= ctrl(s_mar & s_mdr);
m_orden(s_mdr & s_ac & op1 & e_ac & e_nz); -- ac <-- <mdr>
WHEN "0111" => -- JZ
control <= ctrl(s_mar & s_mdr & esc);
IF z = '1' THEN
WAIT UNTIL disp = '1';
m_orden(s_ir & op0 & e_pc); -- pc <-- <ir>
END escritura;
END IF;
BEGIN
WHEN "1000" => -- JNZ
IF z = '1' THEN
END IF;
WHEN "1001" => -- JN
IF n = '1' THEN
END IF;
WHEN "1010" => -- JNN
IF n = '1' THEN
END IF;
WHEN OTHERS =>
m_orden(lec & esc); -- Volcado memoria
m_orden(stop & stop); -- Parada
END CASE;
END PROCESS;
S8 END comportamiento;
39
Reloj
El reloj será el mismo que el utilizado en el modelo anterior pero cambiando el tipo bit por el tipo std_ulogic
en la periferia para compatibilizar sus tipos con los de la UC a la que habrá que conectarlo
ENTITY reloj IS
GENERIC(tl : TIME := 20 ns; th : TIME := 5 ns);
PORT(start : IN bit; stop : IN std_ulogic := '0'; clock : OUT std_ulogic);
END reloj;
ARCHITECTURE comportamiento OF reloj IS
SIGNAL clk : bit := '0';
BEGIN
PROCESS(start, stop, clk)
VARIABLE clke : bit := '0';
BEGIN
IF (start = '1' and NOT start'STABLE) THEN
clke := '1';
clk <= TRANSPORT '0' AFTER th;
END IF;
IF (stop = '1' and NOT stop'STABLE) THEN
clke := '0';
END IF;
IF (clk = '0' and NOT clk'STABLE and clke = '1') THEN
clk <= TRANSPORT '1' AFTER tl;
clk <= TRANSPORT '0' AFTER tl+th;
END IF;
clock <= To_StdUlogic(clk);
END PROCESS;
END comportamiento;
S8 40
Memoria Modelo Estructural de la Ruta de Datos (18)
Al igual que hicimos con el reloj, utilizaremos el mismo modelo anterior cambiando el tipo bit_vector por std_logic_vector en los buses
de datos (bus_dat_sal, bus_dat_ent) y direcciones (bus_dir), y el tipo bit por el std_ulogic en las lineas de control (lec, esc, dis):
USE STD.TEXTIO.aLL; SUBTYPE dir IS NATURAL RANGE 0 TO 255;

USE WORK.std_logic_1164.ALL; VARIABLE direc : dir;
USE WORK.utilidad.ALL; VARIABLE l : LINE;
ENTITY memoria IS CONSTANT c : STRING := " = ";
PORT (bus_dat_sal : OUT std_logic_vector(11 DOWNTO 0); BEGIN
bus_dat_ent : IN std_logic_vector(11 DOWNTO 0); bus_dat_sal <= "ZZZZZZZZZZZZ" AFTER 5 ns;
bus_dir : IN std_logic_vector(11 DOWNTO 0); dis <= '0'AFTER 5 ns;
lec, esc : IN std_ulogic; WAIT UNTIL (lec = '1') OR (esc = '1');
dis : OUT std_ulogic); direc := b_a_n(To_bitvector(bus_dir,'0'));
END memoria; -- Visualiza las 20 primeras posiciones de memoria
ARCHITECTURE comportamiento OF memoria IS IF (esc = '1') AND (lec = '1') THEN --
BEGIN FOR i IN 0 TO 19 LOOP --
PROCESS WRITE(l,i); --
TYPE array_memoria IS WRITE(l, c); --
ARRAY (NATURAL RANGE 0 TO 255) OF WRITE(l, To_bitvector(mem(i))); --
std_logic_vector(11 DOWNTO 0); WRITELINE(OUTPUT, l); --
VARIABLE mem : array_memoria := END LOOP; --
-- programa a ejecutar -- cuando se activan simultáneamente lec y esc
("000100000100", -- 0 LDA (STA índice) ELSIF esc = '1' THEN
"010100000001", -- 1 SUMI 1 mem(direc) := bus_dat_ent;
"001000000100", -- 2 STA (STA índice+1) dis <= '1' AFTER 20 ns;
"000100001110", -- 3 LDA índice WAIT UNTIL esc = '0';
"001000010011", -- 4 STA índice ELSE
"010100000001", -- 5 SUMI 1 bus_dat_sal <= mem(direc) AFTER 15 ns;
"001000001110", -- 6 STA índice dis <= '1' AFTER 20 ns;
"000100001101", -- 7 LDA limite WAIT UNTIL lec = '0';
"011000001101", -- 8 NOR limite END IF;
"010100000001", -- 9 SUMI 1 END PROCESS;
"001100001110", -- 10 SUM índice END comportamiento;
"100000000000", -- 11 JNZ 0
"000000000000", -- 12 HALT
"000000011110", -- 13 limite
"000000010100", -- 14 índice
OTHERS => "000000000000");
S8 41
Conexión estructural Reloj-Memoria-Unidad de Control-Ruta de Datos
reset
start clk
Reloj
stop
MEMORIA
lec
Declaración de entidad disp
esc s_dat e_dat
dir
USE WORK.tipos_control.ALL; sal ent dir
ENTITY comput IS 12 12 12
PORT(start : IN bit; reset : IN std_ulogic := '1'); bus1 bus2
END comput; sel 1
MUX 0
mm
e_mdr
s_mdr MDR
Unidad e_mar
de s_mar MAR
Control
e_pc
s_pc PC
e_ir
s_ir IR
co
4
e_ac
s_ac AC
au
op0 a b
op1
op2 UAL
sn sz
e_nz
s_nz NZ
n
z
S8 42
ARCHITECTURE estructural OF comput IS Arquitectura

COMPONENT reloj
GENERIC(tl,th : TIME := 10 ns);
PORT(start : IN bit; stop : IN std_ulogic; clock : OUT
std_ulogic); SIGNAL control : bus_control;
END COMPONENT; SIGNAL sal, ent : std_logic_vector(11 DOWNTO 0);
COMPONENT u_control SIGNAL dir : std_logic_vector(11 DOWNTO 0);
PORT(disp, n, z : IN std_logic; SIGNAL dis, clk : std_ulogic;
co : IN std_logic_vector(3 DOWNTO 0); SIGNAL n, z : std_logic;
control : OUT bus_control; SIGNAL co : std_logic_vector(3 DOWNTO 0);
clk : IN std_ulogic); BEGIN
END COMPONENT; rel : reloj GENERIC MAP(10 ns, 5 ns) PORT MAP(start, control(stop), clk);
COMPONENT ruta mem : memoria PORT MAP(sal, ent, dir, control(lec), control(esc), dis);
PORT ( e_dat : OUT std_logic_vector(11 DOWNTO 0); con : u_control PORT MAP(dis, n, z, co, control, clk);
s_dat : IN std_logic_vector(11 DOWNTO 0); dat : ruta PORT MAP(ent, sal, dir, clk, reset, control(sel),
dir : OUT std_logic_vector(11 DOWNTO 0); control(e_mdr), control(s_mdr), control(e_mar),
clk, reset, sel, e_mdr, s_mdr, e_mar, s_mar, e_pc, control(s_mar), control(e_pc), control(s_pc),
s_pc, e_ir, s_ir, e_ac, s_ac, control(e_ir), control(s_ir), control(e_ac),
op0, op1, op2, e_nz, s_nz : IN std_ulogic; control(s_ac), control(op0), control(op1),
n, z : OUT std_logic; control(op2), control(e_nz), control(s_nz),
co : OUT std_logic_vector(3 DOWNTO 0)); n, z, co);
END COMPONENT; END estructural;
COMPONENT memoria
PORT (bus_dat_sal : OUT std_logic_vector(11 DOWNTO 0);
bus_dat_ent : IN std_logic_vector(11 DOWNTO 0);
bus_dir : IN std_logic_vector(11 DOWNTO 0);
lec, esc : IN std_ulogic;
dis : OUT std_ulogic);
END COMPONENT;
S8 43
Evolución de buses y señales de control del modelo estructural en la ejecución del programa
ns delta start reset control sal ent dir dis clk n z co
s_mar
e mdr
s mdr
e mar
e_pc
s_pc
e_ir
s_ir
e_ac
s_ac
e_nz
s_nz
stop
op0
op1
op2
lec
esc
sel
0 +0 0 1 UUUUUUUUUUUUUUUUUUU UUUUUUUUUUUU UUUUUUUUUUUU UUUUUUUUUUUU U U U U UUUU
0 +1 0 1 UUUUUUUUUUUUUUUUUUU UUUUUUUUUUUU UUUUUUUUUUUU UUUUUUUUUUUU U 0 U U UUUU
5 +0 1 1 UUUUUUUUUUUUUUUUUUU ZZZZZZZZZZZZ UUUUUUUUUUUU UUUUUUUUUUUU 0 0 U U UUUU
5 +2 1 1 UUUUUUUUUUUUUUUUUUU ZZZZZZZZZZZZ UUUUUUUUUUUU UUUUUUUUUUUU 0 1 U U UUUU
5 +3 1 1 UUUUUUUUUUUUUUUUUUU ZZZZZZZZZZZZ UUUUUUUUUUUU ZZZZZZZZZZZZ 0 1 U U 0000
5 +4 1 1 UUUUUUUUUUUUUUUUUUU ZZZZZZZZZZZZ ZZZZZZZZZZZZ ZZZZZZZZZZZZ 0 1 U U 0000
10 +1 1 1 UUUUUUUUUUUUUUUUUUU ZZZZZZZZZZZZ ZZZZZZZZZZZZ ZZZZZZZZZZZZ 0 0 U U 0000
10 +2 1 1 0000001001000011000 ZZZZZZZZZZZZ ZZZZZZZZZZZZ ZZZZZZZZZZZZ 0 0 U U 0000
10 +4 1 1 0000001001000011000 ZZZZZZZZZZZZ 000000000000 ZZZZZZZZZZZZ 0 0 U U 0000
15 +0 1 1 0000001001000011000 ZZZZZZZZZZZZ 000000000000 ZZZZZZZZZZZZ 0 0 Z Z 0000
25 +3 1 1 0000000100000000000 ZZZZZZZZZZZZ 000000000000 000000000000 0 0 Z Z 0000
25 +4 1 1 0000000100000000000 ZZZZZZZZZZZZ ZZZZZZZZZZZZ 000000000000 0 0 Z Z 0000
48 +0 1 1 1000000100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 0 0 Z Z 0000
50 +0 1 1 1000000100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 0 Z Z 0000
50 +1 1 1 1000000100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 1 Z Z 0000
55 +1 1 1 1000000100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 0 Z Z 0000
55 +2 1 1 1000100100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 0 Z Z 0000
65 +1 1 1 1000100100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 1 Z Z 0000
70 +1 1 1 1000100100000000000 010000000011 ZZZZZZZZZZZZ 000000000000 1 0 Z Z 0000
70 +2 1 1 0000010000100011000 010000000011 ZZZZZZZZZZZZ 000000000000 1 0 Z Z 0000
70 +3 1 1 0000010000100011000 010000000011 ZZZZZZZZZZZZ ZZZZZZZZZZZZ 1 0 Z Z 0000
70 +4 1 1 0000010000100011000 010000000011 010000000011 ZZZZZZZZZZZZ 1 0 Z Z 0000
S8 44
Practica 8 : Diseño de un Computador con VHDL
Objetivos:
Diseño de un computador.
Práctica a realizar:
Diseñar un computador RR (carga-almacenamiento) a tres niveles de resolución:

1. Comportamiento
2. Memoria (comportamiento) -CPU (comportamiento) -Reloj (comportamiento)
3. Memoria (comportamiento) -CPU (estructural) -Reloj (comportamiento)
La especificación de la arquitectura (instrucciones, direccionamientos, etc.) será libre. Como sugerencia se

puede utilizar un subconjunto del DLX como el que se presenta en la transparencia siguiente
Resultados a entregar:
Documentación del diseño incluyendo:
1. Especificación completa y precisa de la arquitectura del computador.
2. Listado VHDL comentado de los programas correspondientes a cada modelo.
3. Visualización de los resultados y/o valores de los buses y registros en el proceso de
ejecución de un programa de test.
S8 45
Arquitectura del DLX (subconjunto)
Repertorio de Instrucciones
Instrucción Simbólico Operación
Menor que (R) slt r1, r2, r3 if (r2 < r3) r1<-1 else r1<-0
Menor que (I) slti r1, r2, #n if (r2 < n) r1<-1 else r1<-0
Mayor que (R) sgt r1, r2, r3 if (r2 > r3) r1<-1 else r1<-0
Mayor que (I) sgti r1, r2, #n if (r2 > n) r1<-1 else r1<-0
Igual (R) seq r1, r2, r3 if (r2 = r3) r1<-1 else r1<-0
Igual (I) seqi r1, r2, n if (r2 = n) r1<-1 else r1<-0
Arquitectura
No igual (R) sne r1, r2, r3 if (r2 ≠ r3) r1<-1 else r1<-0
No igual (I) sne r1, r2, #n if (r2 ≠ n) r1<-1 else r1<-0
Suma ® add r1, r2, r3 r3 Å <r1> + <r2>

Suma (I) addi r1, r2, #n r2 Å <r1> + n Registros
Resta (R) sub r1, r2, r3 r3 Å <r1> - <r2>
Memoria
Resta (I) subi r1, r2, #n r2 Å <r1> - n
Y-lógica (R) and r1, r2, r3 r3 Å <r1> AND <r2>
Y-lógica (I) and r1, r2, #n r2 Å <r1> AND n UAL
Salto si = 0 beqz if(r1==0) pc Å dirección
Salto si ≠ 0 bnez if(r1 ≠ 0) pc Ådirección
Bifurcación j nombre Pc Å dirección
Bifurcación reg. jr r1 pc Å r1
Carga lw r3 Å M[r1 + dirección]
Almacenamiento sw M[r1 + dirección] Å r3
S8 46

Sesion 8

Cargado por

Copyright:

Formatos disponibles

Sesion 8

Cargado por

Información del documento

Título original

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

Sesion 8

Cargado por

Copyright:

Formatos disponibles

Sesión 8: Diseño de un Computador con VHDL

Formato de las instrucciones

• 3 de carga y almacenamiento (LDA, STA, LDAI)

Nombre Simbólico DIR/OPE COP Significado

LDA DIR 0001 AC <-- MEM(DIR)

Simbólico Binario Simbólico Binario

El ciclo se controla comprobando cuando el índice

Para ello se realiza la resta limite - índice,

start • La carga inicial del programa a ejecutar se define como

• Fases en la ejecución de una instrucción:

Transferencias elementales para cada instrucción

<PC> = contenido del pc <AC> = contenido del ac <NZ> = contenido de nz

CONSTANT c : STRING := " = ";

WRITE(l,cpc); -- rotulo delpc, es decir, <PC> =

• En este segundo modelo descompondremos el computador en sus dos unidades básica:

• El reloj del sistema también lo modelaremos como una entidad

CPU s_dat e_dat dir

Modelo VHDL del Reloj

bus_dat_sal bus_dat_ent bus_dir

Modelo VHDL de la Memoria (2)

ARCHITECTURE comportamiento OF memoria IS BEGIN

Modelo VHDL de la Unidad Central de Proceso

Procedimiento de lectura Procedimiento de escritura

PROCEDURE lectura IS PROCEDURE escritura IS

Modelo Estructural CPU-Memoria

ENTITY comput IS PORT (start : IN bit);

ARCHITECTURE comportamiento OF mux IS

e_r e_r registro s_r

• la UC generará las señales específicas que

Cronogramas correspondientes a las instrucciones SUM y STA

Cronogramas correspondientes a las instrucciones LDAI, JNZ y HALT.

clk clk clk

la señal stop, que bloquea la clk

generación de pulsos de reloj lec

Modelo de comportamiento de la Unidad de Control

Arquitectura: procedimientos auxiliares

PROCEDURE lectura IS PROCEDURE escritura IS

Arquitectura m_orden(s_pc & op2 & e_pc);

USE STD.TEXTIO.aLL; SUBTYPE dir IS NATURAL RANGE 0 TO 255;

ARCHITECTURE estructural OF comput IS Arquitectura

Diseñar un computador RR (carga-almacenamiento) a tres niveles de resolución:

La especificación de la arquitectura (instrucciones, direccionamientos, etc.) será libre. Como sugerencia se

Suma ® add r1, r2, r3 r3 Å <r1> + <r2>

Salto si ≠ 0 bnez if(r1 ≠ 0) pc Ådirección

Bifurcación j nombre Pc Å dirección

Carga lw r3 Å M[r1 + dirección]

Almacenamiento sw M[r1 + dirección] Å r3

También podría gustarte