SIMULACION DE UN PROCESADOR DE 8 BITS CON LENGUAJE DE DESCRIPCION DE HARDWARE VHDL MEDIANTE METODOLOGIAS DE DISEO DESCENDENTE

LUIS EDUARDO ABAD QUINTERO

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA Y ARQUITECTURA DEPARTAMENTO DE ELECTRICIDAD ELECTRONICA Y COMPUTACION MANIZALES CALDAS 2002

SIMULACION DE UN PROCESADOR DE 8 BITS CON LENGUAJE DE DESCRIPCION DE HARDWARE VHDL MEDIANTE METODOLOGIAS DE DISEO DESCENDENTE

LUIS EDUARDO ABAD QUINTERO

Trabajo de grado para optar al ttulo de Ingeniero Electrnico

Director FLAVIO PRIETO Ingeniero Electrnico

UNIVERSIDAD NACIONAL DE COLOMBIA FACULTAD DE INGENIERIA Y ARQUITECTURA DEPARTAMENTO DE ELECTRICIDAD ELECTRONICA Y COMPUTACION MANIZALES CALDAS 2002

CONTENIDO Pg.

INTRODUCCION 1. MARCO TEORICO 1.1 RESEA HISTORICA 1.2 DEFINICION DEL PROBLEMA 1.2.1 Set de instrucciones 1.2.2 Formato de instrucciones 1.2.3 Libreras y paquetes 1.2.4 Basic_utilities 1.2.5 Par_utilities 1.2.6 Estructura de buses 2. DISEO DESCENDENTE (TOP-DOWN) DEL PROCESADOR 2.1 UNIDAD DE CONTROL 2.2 ESTRUCTURA DE BUSES 2.3 UNIDAD LOGICO ARITM ETICA (arithmetic_logic_unit.vhd) 2.4 UNIDAD DE CORRIMIENTO (shifter_unit.vhd) 2.5 UNIDAD DE REGISTRO DE ESTADO (status_register_unit.vhd) 2.6 ACUMULADOR (accumulator_unit.vhd) 2.7 REGISTRO DE INSTRUCCION (instruction_register_unit.vhd) 2.8 REGISTRO CONTADOR DE PROGRAMA (program_counter_register_unit.vhd) 2.9 REGISTRO DE DIRECCIONAMIENTO DE MEMORIA (memory_address_register_unit.vhd) 2.10 TRANSFERENCIA DE DATOS ENTRE REGISTROS (par_data_path) 2.11 SIMULACION DE LA UNIDAD DE CONTROL (unit_control.vhd) iii

1 3 3 4 5 6 7 8 9 11 13 14 14 15 18 20 21 22

24

25 27 30

2.12 INTERCONEXION DE BUSES Y UNIDAD DE CONTROL (par_central_processing_unit.vhd) 3. RESULTADOS CONCLUSIONES BIBLIOGRAFA ANEXOS 31 33 43 45 46

iv

LISTA DE TABLAS Pg.

Tabla 1. Set de instrucciones Tabla 2. Formato de instrucciones Tabla 3. Operaciones y banderas de la unidad lgico aritmtica Tabla 4. Programa de prueba Tabla 5. Valores de estado (datos u operandos) en memoria Tabla 6. Valores de operacin and Tabla 7. Seales afectadas por instrucciones de un byte Tabla 8. Seales afectadas por instrucciones de dos bytes

5 7 15 36 38 41 48 49

LISTA DE FIGURAS Pg.

Figura 1. Estructura de buses Figura 2. Esquema jerrquico del sistema Figura 3. Esquema lgico de la unidad lgico aritmtica Figura 4. Hardware de un bit para la unidad lgico aritmtica Figura 5. Esque ma lgico de la unidad de corrimiento Figura 6. Esquema lgico del registro de estado Figura 7. Esquema lgico del acumulador Figura 8. Esquema lgico del registro de instruccin Figura 9. Esquema lgico del registro contador de programa Figura 10. Esquema lgico del registro de direccionamiento de memoria Figura 11. Diagrama de tiempo de la instruccin lda i8 Figura 12. Diagrama de tiempo de la instruccin sub 6 Figura 13. Diagrama de tiempo de la instruccin jmp 9 Figura 14. Diagrama de tiempo de las instrucciones nop y cac Figura 15. Diagrama de tiempo de la instruccin asl Figura 16. Diagrama de tiempo de la instruccin cmc Figura 17. Diagrama de tiempo de la instruccin branch_c 20 Figura 18. Diagrama de tiempo de la instruccin and i25 Figura 19. Diagrama de tiempo de la instruccin cla Figura 20. Compilador Max Plus II Figura 21. Cuadro de dilogo: VHDL Netlist Reader Settings Figura 22. Cuadro de dilogo: Device Figura 23. Cuadro de dilogo: Enter Nodes from SNF Figura 24. Cuadro de dilogo: End Time vi

12 14 17 17 20 20 23 23 25 25 37 38 38 39 39 40 40 41 42 54 55 56 56 57

Figura 25. Cuadro de dilogo: Grid Size Figura 26. Cuadro de dilogo: Overwrite Clock Figura 27. Simulador de Max Plus II

57 57 58

vii

LISTA DE LISTADOS

Pg.

Listado 1. Basic_utilities.vhd Listado 2. Par_utilities.vhd Listado 3. Alu_operations.vhd Listado 4. Arithmetic_logic_unit.vhd Listado 5. Shifter_unit.vhd Listado 6. Status_register_unit.vhd Listado 7. Accumulator_unit.vhd Listado 8. Instruction_register_unit.vhd Listado 9. Program_counter_unit.vhd Listado 10. Memory_address_register_unit.vhd Listado 11. Entidad de par_dat_path.vhd Listado 12. Declaracin de componentes y seales de par_data_path.vhd Listado 13. Asignacin de seales de par_data_path.vhd Listado 14. Entidad de par_control_unit.vhd Listado 15. Par_central_processing_unit.vhd Listado 16. Parwan_tester.vhd Listado 17. Instruccin.vhd Listado 18. Secuencia de estados (s1-s3) de par_control_unit.vhd Listado 19. Estado s4 de par_control_unit.vhd Listado 20. Secuencia de estados (s5-s6) de par_control_unit.vhd Listado 21. Secuencia de estados (s7-s9) de par_control_unit.vhd Listado 22. Asignacin de seales de par_control_unit.vhd

8 9 16 17 19 21 22 23 24 26 27 28 29 30 31 33 35 48 49 50 50 49

viii

LISTA DE ANEXOS

Pg.

Anexo A. Unidad de control Anexo B. Max Plus II

46 53

ix

INTRODUCCION

Este documento presenta una visin del diseo descendente de un sistema digital, usando el lenguaje VHDL (VHSIC Hardware Description Lenguage). Se examinan las diferentes etapas de diseo descendente, el cual parte de unos requerimientos especficos de alto nivel que deben ser cumplidos por el sistema para conseguir un ptimo desempeo. El sistema diseado es un procesador de ocho bits.

CONTENIDO

Inicialmente se define la arquitectura completa del sistema a ser estudiado, la cual se somete a un anlisis descendente, dividindose reiteradamente en subsistemas bsicos o fundamentales que representen menor complejidad al momento de simular a partir de las funciones lgicas elementales. Finalmente, despus de verificar el funcionamiento aislado

TABLAS
FIGURAS LISTADOS

se realiza una interconexin ascendente de cada una de los componentes ya simulados.

ANEXOS

Para este proyecto se opt por el software de desarrollo Max Plus II, programa que permite realizar un diseo digital mediante lenguaje VHDL, para dispositivos programables de las familias Acex, Flex y Max; pertenecientes a la empresa Altera; adoptados como herramientas de trabajo en el rea de sistemas digitales por la Universidad Nacional de Colombia, Sede Manizales. Estos dispositivos ofrecen un rango de entre 600 y 250.000 compuertas, adems los productos de Altera permiten sintetizar bajo cualquiera de las plataformas PC y UNIX. Naturalmente el programa Max Plus II est diseado para la sntesis de circuitos y no para la simulacin por lo que no admite retrasos, ni se adapta 100% con el VHDL.

El sistema a estudiar en este proyecto es un pequeo procesador, el cual fue desarrollado con fines pedaggicos utilizando tcnicas de mediana (MSI) y pequea (SSI) escala de integracin, emplea reducidos requerimientos de hardware y un sencillo set de

instrucciones. Se pretende ilustrar el uso de VHDL como un lenguaje de modelado y diseo para arquitecturas de procesadores donde se enfatiza en los componentes discretos.

El documento se divide en tres captulos : el captulo uno plantea de forma muy general el diseo, contextualiza al lector sobre la importancia de los lenguajes de descripcin de hardware (HDLs) en la evolucin del diseo digital moderno y contiene las especificaciones funcionales del procesador. El segundo captulo plantea la forma de

diseo descendente donde se segrega el sistema en unidades funcionales ms pequeas, partiendo de niveles de abstraccin ms profundos hasta llegar a los de transferencia de registro (RT) que permiten ser simulados con VHDL Finalmente el captulo tres ilustra mediante diagramas de tiempo los resultados obtenidos en la ejecucin de un programa compuesto por algunas instrucciones representativas.
CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

1 MARCO TEORICO

1.1 RESEA HISTORICA

Las caractersticas ms destacadas de las tendencias actuales en diseo de sistemas electrnicos se pueden resumir en un incremento creciente de la complejidad de los sistemas a desarrollar, as como la necesidad de incluir un cierto grado de flexibilidad que permita afrontar posibles
CONTENIDO

modificaciones o actualizaciones futuras.

TABLAS

Como consecuencia de ello se produjo un cambio progresivo en la metodologa de diseo

FIGURAS LISTADOS

utilizada. Esta se basa fundamentalmente en la utilizacin de herramientas de simulacin y sntesis de alto nivel. Diversos grupos de investigadores desarrollaron los llamados lenguajes de descripcin de hardware. Empresas tales como IBM con su IDL, el TI-HDL de Texas

ANEXOS

Instruments, ZEUS de General Electric, etc.

Sin embargo estos lenguajes nunca alcanzaron los niveles de difusin y consolidacin necesarios por motivos distintos. Los industriales, por ser propiedad de las empresas permanecieron encerrados en ellas y no estuvieron disponibles para su mayor estandarizacin y difusin y los universitarios, perecieron por no disponer de los recursos adecuados.

En 1980 el gobierno de los Estados Unidos de Amrica cre el proyecto VHSIC (Very High Speed Integrated Circuit) con el objeto de desarrollar el proceso tecnolgico utilizado para la creacin de circuitos integrados, rentabilizando las inversiones en hardware y haciendo ms sencillo su mantenimiento. Se pretenda con ello resolver el problema de modificar el hardware diseado en un proyecto para utilizarlo en otro. Tras varias versiones llevadas a cabo con

colaboracin de la industria y las universidades; el IEEE adopto en diciembre de 1987 a VHDL 3

(VHSIC Hardware Description Lenguage) como su lenguaje HDL, dando un impulso a ste frente a sus competidores. El estndar std 1076-1987 constituy el punto firme de partida de lo que despus de cinco aos sera ratificado como VHDL.

La utilizacin del lenguaje VHDL se justifica esencialmente por las diferentes ventajas que ofrece, entre estas encontramos : la estandarizacin, por parte de la IEEE, como del gobierno Norteamericano y de las industrias que lo emplean en sus diseos comerciales; la portabilidad, al permitir que el mismo cdigo sea usado y simulado en diferentes herramientas como sea necesario; la capacidad de modelizacin, de todos los niveles de diseo desde componentes complejas hasta transistores, la reusabilidad, al permitir libreras con componentes comnmente utilizados, la independencia de la tecnologa, que permite describir y verificar un diseo independientemente de la tecnologa que lo soporte. Todas estas ventajas permiten una
CONTENIDO

simulacin rpida y constante durante todo el desarrollo, repercutiendo directamente en la obtencin de un menor tiempo de diseo, posibilitando llegar a modelos funcionales de forma directa partiendo de las especificaciones y otorgando cierta flexibilidad frente a diferentes soluciones de diseo.

TABLAS
FIGURAS LISTADOS

ANEXOS

1.2 DEFINICION DEL PROBLEMA

Se utilizar el programa Max Plus II de Altera, para simular mediante lenguaje VHDL, un procesador con dos buses, uno de datos externo de ocho bits y otro de direccionamiento de memoria compuesto por doce bits, denominados como databus y adbus respectivamente; posee adems dos entradas de un bit cada una, que harn las veces de timer y reset.

Databus permite el flujo de datos entre el procesador y la memoria externa ROM la cual contiene los datos e instrucciones que conforman el programa a ejecutar. El tamao de adbus permite acceder 4096 bytes de memoria, divididas en 16 segmentos de 256 bytes cada uno; los cuatro bits ms significativos determinan el segmento (page) de memoria a direccionar, mientras 4

que los ocho menos significativos hacen lo propio con el desplazamiento (offset). Esta mquina est diseada para ejecutar instrucciones lgicas y aritmticas elementales y de salto. 1.2.1 Set de Instrucciones. El procesador tiene un total de 21 instrucciones (vase Tabla 1), con cinco instrucciones que pueden ser usadas en dos modos de direccionamiento: directo e indirecto. El registro de datos (registro principal) es el acumulador (ac), el cual es utilizado por la mayora de las instrucciones. Esta mquina posee cuatro banderas: sobreflujo, acarreo, zero y negativo (v, c, z y n). Las banderas son afectadas por diferentes instrucciones que actualizan el contenido del acumulador.

Tabla 1. Set de instrucciones

BITS DE % DE DIR. Completo Completo Completo Completo Completo Segmento Segmento Segmento Segmento Segmento Ninguno Ninguno Ninguno Ninguno Ninguno Ninguno DIR. INDIRECTO Si Si Si Si Si No No No No No No No No No No No BANDERAS UTILIZADAS -- -- -- --- -- -- --- c -- --- c -- --- -- -- --- -- -- -v -- -- --- c -- --- -- z --- -- -- n -- -- -- --- -- -- --- -- -- --- -- -- --- -- -- --- -- -- -BANDERAS AFECTADAS -- -- z n -- -- z n v c z n v c z n -- -- -- --- -- -- --- -- -- --- -- -- --- -- -- --- -- -- --- -- -- --- -- -- --- -- z n -- c -- -v c z n -- -- z n

CONTENIDO

INSTRUCCIN LDA loc AND loc

DESCRIPCIN Cargar AC en loc AND AC y loc Suma loc y AC Resta loc de AC Salta hasta adr

DIR 12 12 12 12 12 8

TABLAS
FIGURAS LISTADOS

ADD loc SUB loc JMP adr JSR tos

ANEXOS

BRA_V adr BRA_C adr BRA_Z adr BRA_N adr NOP CLA CMA CMC ASL ASR

Salta hasta adr si v Salta hasta adr si c Salta hasta adr si z Salta hasta adr si n No operacin Limpiar AC Complementar AC Complementar carry Corrimiento izquierda Corrimiento derecha

8 8 8 8 -------

DIR. : Direccionamiento loc : Direccin de memoria (operando) adr : Direccin de memoria (instruccin) tos : Direccin de memoria (inicio de rutina)

La instruccin lda carga el acumulador con un byte de memoria, mientras que las instrucciones and, add y sub acceden a la memoria por un operando, realizan la operacin especfica con el contenido del acumulador, y cargan este ltimo con el resultado, estas operaciones afectan las banderas. La ejecucin de jmp hace que la siguiente instruccin a ser ejecutada provenga de la direccin especificada. Las instrucciones lda, and, add, sub y jmp utilizan doce bits de direccionamiento; distribuidos entre los cuatro menos significativos del primer byte (segmento) y los ocho restantes del segundo byte (desplazamiento); lo que les permite acceder a diferentes segmentos de memoria. Estas instrucciones pueden ser usadas en el modo de direccionamiento indirecto.

Las instrucciones

de salto

jsr

branch

utilizan ocho bits de direccionamiento,

correspondientes al segundo byte, como consecuencia no pueden direccionar un segmento de

CONTENIDO

memoria diferente. La instruccin jsr establece como la prxima instruccin a ejecutar, la contenida en la posicin de memoria definida por el byte de direccionamiento ms uno. Las instrucciones branch_v, branch_c, branch_z y branch_n, cargan la posicin correspondiente al segundo byte como la prxima instruccin si las respectivas banderas v, c, z y n se encuentran

TABLAS
FIGURAS LISTADOS

activas.

ANEXOS

Las operaciones nop, cla, cma, asl, y asr son instrucciones de un solo byte, actan sobre los registros internos y no necesitan direccionar operandos de memoria. La instruccin nop no desarrolla operacin alguna, cla limpia el acumulador, cma complementa el acumulador, cmc complementa la bandera de acarreo, y asl y asr causan corrimientos aritmticos del contenido del acumulador a la izquierda y derecha respectivamente.

1.2.2 Formato de instrucciones. Hay tres grupos de instrucciones (vase Tabla 2). Las de direccionamiento completo, compuestas por dos bytes, pueden acceder a toda la memoria y trabajar en modo de direccionamiento indirecto. Las de direccionamiento de segmento que requieren dos bytes pero no pueden direccionar otro segmento diferente al actual y slo trabajan en modo de direccionamiento directo. Finalmente, el tercer grupo, formadas por un solo byte, estas instrucciones no utilizan datos de memoria para sus operandos, por consiguiente no 6

requieren byte de direccionamiento. El formato de instrucciones es indispensable al momento de programar la memoria como se ver ms adelante.

Tabla 2. Formato de instrucciones

MODO INSTRUCCIN ENCABEZADO Bits 7 6 5 DIRECCIONAMIENTO D/I Bit 4 Bits 3 2 1 0

LDA loc AND loc ADD loc SUB loc JMP adr

0 0 0 0 0 1 0 1 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

0 / 1 0 / 1 0 / 1 0 / 1 0 / 1 --1 1 1 1 0 0 0 0 0 0

Direccin de segmento Direccin de segmento Direccin de segmento Direccin de segmento Direccin de segmento --- --- --- --1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 1 0 0 1 0 0 1 0 0 0 1 0 0 1

CONTENIDO

JSR tos BRA_V adr

TABLAS
FIGURAS LISTADOS

BRA_C adr BRA_Z adr BRA_N adr NOP CLA

ANEXOS

CMA CMC ASL ASR

1.2.3 Libreras y paquetes. Se emplean las libreras IEEE, de 1993 ( td_logic, std_arith, s std_signed, std_unsigned), para hacer uso de sus tipos de datos estndar en este caso std_ulogic, std_ulogic_vector y sus subconjuntos. Se utilizan unos paquetes bsicos que permiten agrupar un conjunto de declaraciones para su posterior uso en diferentes dispositivos, entre estos debemos mencionar: * basic_utilities, la cual pone a disposicin funciones que permiten simular la estructura de buses; * par_utilities, que define vectores de longitud definida y otras funciones

para realizar operaciones entre estos como adicin y sustraccin; * par_parameters, define a nivel de bits los encabezados de las diferentes instrucciones.

1.2.4 Basic_Utilities. Este paquete define funciones que permiten obtener vectores de datos con diferentes longitudes a partir de elementos individuales, tambin permite incrementar registros (vase listado 1).

Listado 1. Basic_utilities.vhd

CONTENIDO

TABLAS
FIGURAS LISTADOS

PACKAGE basic_utilities IS --incrementa registro de 12 bits FUNCTION inc (x: STD_LOGIC_VECTOR (11 DOWNTO 0)) RETURN -- retorna vectores de bits aislados FUNCTION x01z2vector8(b0, b1, b2, b3, b4, b5, b6, b7 : x01z) RETURN FUNCTION x01z 2vector6(b0 ,b1, b2, b3, b4, b5 : x01z) RETURN FUNCTION x01z2vector4(b0, b1, b2 ,b3 : x01z) RETURN -END basic_utilities;

STD_LOGIC_VECTOR; STD_LOGIC_VECTOR; STD_LOGIC_VECTOR; STD_LOGIC_VECTOR;

ANEXOS

PACKAGE body basic_utilities IS ---FUNCTION inc(x : STD_LOGIC_VECTOR(11 DOWNTO 0) ) RETURN STD_LOGIC_VECTOR IS VARIABLE re : STD_LOGIC_VECTOR(11 DOWNTO 0); VARIABLE ca : STD_LOGIC_VECTOR(11 DOWNTO 0); BEGIN ca(0) := x(0); re(0) := not x(0); for i in 1 to 11 loop ca(i) := x(i) and ca(i-1); re(i) := x(i) xor ca(i-1); END loop; RETURN re; END inc; -- retorna vector de ocho elementos FUNCTION x01z2vector8(b0, b1, b2, b3, b4, b5, b6, b7 :x01z) RETURN STD_LOGIC_VECTOR IS VARIABLE provi : STD_LOGIC_VECTOR(7 DOWNTO 0); BEGIN provi(0):=b7; provi(1):=b6; provi(2):=b5; provi(3):=b4; provi(4):=b3; provi(5):=b2; provi(6):=b1; provi(7):=b0; RETURN provi; END; --retorna vector de seis elementos FUNCTION x01z2vector6(b0, b1, b2, b3, b4, b5 : x01z) RETURN STD_LOGIC_VECTOR IS VARIABLE provi : STD_LOGIC_VECTOR (5 DOWNTO 0); BEGIN provi(0) := b5; provi(1) := b4; provi(2) := b3; provi(3) := b2; provi(4) := b1; provi(5) := b0;

RETURN provi; END; --

--retorna vector de cuatro elementos FUNCTION x01z2vector4(b0, b1, b2, b3 : x01z) RETURN STD_LOGIC_VECTOR IS VARIABLE provi : STD_LOGIC_VECTOR (3 DOWNTO 0); BEGIN provi(0) := b3; provi(1) := b2; provi(2) := b1; provi(3) := b0; RETURN provi; END; -END basic_utilities;

1.2.5
CONTENIDO

Par_Utilities.

Define

los

subtipos

nibble,

byte

twelve

como

vectores

STD_LOGIC_VECTOR de cuatro, ocho y doce elementos respectivamente. Adems incluye las funciones add_cv y sub_cv. Estas funciones realizan las operaciones de adicin y substraccin respectivamente sobre vectores de longitud siete y retornan vectores de nueve elementos, donde

TABLAS
FIGURAS LISTADOS

los dos bits ms significativos corresponden a las banderas de acarreo y sobreflujo respectivamente. La ltima funcin es set_if_zero, la cual retorna 1 si todos los elementos del vector son ceros (vase listado2).

ANEXOS

Listado 2. Par_utilities.vhd

PACKAGE par_utilities IS --subtipos de vectores SUBTYPE nibble IS STD_LOGIC_VECTOR (3 DOWNTO 0); SUBTYPE byte IS STD_LOGIC_VECTOR (7 DOWNTO 0); SUBTYPE twelve IS STD_LOGIC_VECTOR (11 DOWNTO 0); -CONSTANT zero_4:nibble := "0000"; CONSTANT zero_8:byte := "00000000"; CONSTANT zero_12:twelve := "000000000000"; --funciones de suma y resta FUNCTION add_cv(a,b:STD_LOGIC_VECTOR(7 DOWNTO 0);cin:x01z) RETURN . .. STD_LOGIC_VECTOR; FUNCTION sub_cv(a,b:STD_LOGIC_VECTOR(7 DOWNTO 0);cin:x01z) RETURN STD_LOGIC_VECTOR; -- retorna 1 si a = 0 FUNCTION set_if_zero(a:STD_LOGIC_VECTOR) RETURN STD_LOGIC; END par_utilities;

--cuerpo del paquete -PACKAGE body par_utilities IS

CONTENIDO

-- a + b FUNCTION add_cv(a, b: STD_LOGIC_VECTOR(7 DOWNTO 0) ; cin:in x01z) VARIABLE re : STD_LOGIC_VECTOR ( 9 DOWNTO 0 ); VARIABLE ca : STD_LOGIC_VECTOR (a'RANGE); BEGIN ca(0) := ((a(0) XOR b(0)) AND cin) OR (a(0) AND b(0)); re(0) := (a(0) XOR b(0)) XOR cin; FOR I IN 1 TO 7 LOOP ca(i) := ((a(i) XOR b(i)) AND ca(i-1)) OR (a(i) AND b(i)); re(i) := (a(i) XOR b(i)) XOR ca(i-1); END LOOP; re(8) := ca(7); IF a(7) = b(7) AND re(7) /= a(7) THEN re(9):='1'; ELSE re(9):='0'; END IF; RETURN re; END add_cv;

STD_LOGIC_VECTOR

IS

TABLAS
FIGURAS LISTADOS

ANEXOS

-- a + ( -b ) = a - b FUNCTION sub_cv(a, b: STD_LOGIC_VECTOR(7 DOWNTO 0) ; cin : x01z) RETURN STD_LOGIC_VECTOR IS VARIABLE not_b : STD_LOGIC_VECTOR (7 DOWNTO 0); VARIABLE not_c : x01z; VARIABLE r : STD_LOGIC_VECTOR (9 DOWNTO 0); BEGIN not_b := not(b); not_c := NOT cin; r := add_cv(a, not_b, not_c); RETURN r; END sub_cv; ---retorna 1 si los valores del vector son todos 0 -FUNCTION set_if_zero(a:STD_LOGIC_VECTOR(7 DOWNTO 0)) RETURN STD_LOGIC IS VARIABLE zero : STD_LOGIC := '1'; BEGIN FOR I IN a'RANGE LOOP IF a(i) /= '0' THEN zero := '0'; END IF; END LOOP; RETURN zero; END set_if_zero; -END par_utilities;

10

1.2.6. Estructura de buses. La estructura de buses de una CPU describe la forma de cmo sus registros y unidades lgicas estn conectadas. El primer paso en el proceso del diseo del hardware de una CPU es el diseo de esta estructura. En la estructura de buses del procesador (vase Figura 1) los tringulos blancos indican una interconexin controlada por otra seal, o asignaciones condicionales, mientras los rellenos muestran conexiones permanentes.

Este diagrama de buses es til al realizar un estudio detallado del tiempo en la ejecucin de cada una de las instrucciones de mquina y de la descripcin del procesador completo, como se ver ms adelante. En este diagrama los nombres de los buses y registros ms importantes aparecen con letras maysculas, y todas las otras seales en minsculas. El procesador est formado por siete componentes: el acumulador (ac) es un registro de ocho bits
CONTENIDO

que proporciona un operando a la unidad lgico aritmtica (alu), el registro de instruccin (ir) se conecta al dbus a travs de la alu y provee de instrucciones al controlador y direccin de segmento al bus de direccionamiento (adbus), el registro de doce bits contador de programa (pc)

TABLAS
FIGURAS LISTADOS

es un contador binario ascendente que provee direcciones de instrucciones al adbus a travs del registro de direccionamiento de memoria (mar), el registro de estado (sr) almacena las banderas, la unidad lgico-aritmtica (alu) y unidad de corrimiento (shu) son unidades lgicas combinacionales. Los registros mar y pc tienen secciones de segmento y desplazamiento que estn identificadas como mar_page, pc_page, mar_offset y pc_offse, los nmeros de los

ANEXOS

segmentos son guardados en sus cuatro bits ms significativos, cada componente posee seales de entrada, salida y control. Adems, los registros tienen entradas de sincronizacin que estn conectadas al reloj del sistema principal.

11

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 1. Estructura de buses 12

2 DISEO DESCENDENTE (TOP-DOWN) DEL PROCESADOR

En los ltimos tiempos las metodologas de diseo de circuitos digitales han evolucionado desde los mtodos clsicos basados en capturas de esquemas lgicos, hacia la descripcin de los circuitos con lenguajes de descripcin de hardware (HDLs). El uso de estos lenguajes, ha hecho evolucionar la forma de concebir los circuitos, imponindose actualmente las metodologas de diseo descendentes o " top-down" en las que los circuitos se definen desde una descripcin funcional de su comportamiento, en el nivel de
CONTENIDO

abstraccin denominado de transferencia de registros (RTL). Este mtodo de diseo se ha desarrollado principalmente por la aparicin de la sntesis lgica basadas en HDLs, que permite la traduccin automtica de las descripciones funcionales, a lo largo del ciclo de

TABLAS
FIGURAS LISTADOS

diseo, en descripciones estructurales de ms bajo nivel de abstraccin como puertas lgicas.

ANEXOS

El sistema est formado por una entidad superior (vase Figura 2), o UNIDAD CENTRAL DE PROCESAMIENTO, que define los puertos del procesador, esta unidad a su vez est formada por dos entidades: UNIDAD DE CONTROL y ESTRUCTURA DE BUSES. Es importante resaltar que todas las entidades independientemente del nivel de jerarqua que ocupen en la estructura, tienen en su declaracin de interface un puerto de entrada comn clk que recibe la seal del reloj (MAESTRO).

13

Figura 2. Diagrama jerrquico del sistema

2.1 UNIDAD DE CONTROL

CONTENIDO

TABLAS
FIGURAS LISTADOS

Consiste en una mquina de estados, 26 en total (vase anexo A), donde cada uno de ellos acta sobre una serie de seales de control por exactamente un perodo de reloj, estas seales son enviadas a la ESTRUCTURA DE BUSES y determinan el flujo de datos por los diferentes registros, elementos combinacionales y memoria externa que componen el

ANEXOS

sistema, tambin recibe de la estructura un vector de datos y uno de banderas, que determinan la transicin de estados de acuerdo a la instruccin a ejecutar.

2.2 ESTRUCTURA DE BUSES La estructura de buses de una CPU describe la forma cmo sus registros y unidades lgicas estn conectadas. El primer paso en el proceso del diseo del hardware de una CPU es el diseo de esta estructura. La figura 1 muestra la estructura de buses del procesador. Este diagrama es til al realizar un estudio detallado del tiempo en la ejecucin de cada una de las instrucciones de mquina y de la descripcin del procesador completo, como se v er ms adelante.

14

La estructura de buses est compuesta por siete elementos, de los cuales el acumulador ac, el registro de instruccin ir, el contador de programa pc, el registro de direccionamiento de memoria mar, y el registro de estado sr son registros, y la unidad lgica y aritmtica alu y la unidad de corrimiento shu son unidades lgicas combinacionales. Cada componente posee seales de entrada, salida y control. Adems, los registros tienen entradas de sincronizacin que estn conectadas al reloj del sistema principal.

Los registros mar y pc tienen partes de segmento y desplazamiento que estn identificadas como mar_page, pc_page, mar_offset y pc_offset. Los nmeros de los segmentos son guardados en sus cuatro bits ms significativos. La unidad lgica y aritmtica, alu, tiene dos entradas de ocho bits, cuatro banderas de entrada, y tres seales de control entrando. Las salidas de esta unidad estn conectadas a las entradas de la unidad de corrimiento shu.
CONTENIDO

La unidad de corrimiento shu realiza desplazamientos hacia la derecha o hacia la izquierda de sus operandos de ocho bits. El registro de estado, sr, tiene cuatro entradas y cuatro salidas, las cuales pasan a travs de la alu, y de la shu, para regresar a sus entradas. Esto permite a las banderas ser modificadas por cada una de estas unidades.

TABLAS
FIGURAS LISTADOS

ANEXOS

2.3 UNIDAD LOGICO ARITM ETICA ( aritmetic_logic_unit.vhd) La alu tiene dos operandos de ocho bits, seis lneas para seleccionar operaciones, cuatro banderas de entrada, una salida de datos de ocho bits y cuatro banderas de salida. Las seis lneas de seleccin permiten escoger la operacin a realizar (vase Tabla 3).

Tabla 3. Operaciones y Banderas de la unidad lgico aritmtica

Id 0 1 2 3 4 5 Lnea de seleccin alu_and alu_not Alu_a alu_and Alu_b alu_sub operacin a AND b NOT b A b PLUS a b b MENOS a Banderas afectadas z, n z, n z, n v, c, z, n z, n v, c, z, n

15

Esta tabla muestra tambin las banderas que pueden resultar afectadas por las operaciones.

La Figura 3 muestra el diagrama lgico de la alu para el procesador. Esta imagen sigue los estndares de la IEEE para la representacin de componentes digitales. La figura 4 muestra una posible forma de implementar el hardware para un bit de la alu. Las lneas de seleccin permiten elegir una entre las seis operaciones posibles a realizar. Para implementar esta alu, el paquete alu_operations.vhd (vase listado 4) es usado en adicin con basic_utilities y par_utilities. Alu_operations define nombres equivalentes para los cdigos de operaciones de la alu y se utiliza para incrementar la legibilidad del cdigo.

Listado 3. Alu_operations.vhd
CONTENIDO
PACKAGE alu_operations CONSTANT a_and_b : CONSTANT b_compl : CONSTANT a_input : CONSTANT a_add_b : CONSTANT b_input : CONSTANT a_sub_b : END alu_operations; IS STD_LOGIC_VECTOR ( 5 DOWNTO 0 ) := "000001" ; STD_LOGIC _VECTOR ( 5 DOWNTO 0 ) := "000010" ; STD_LOGIC _VECTOR ( 5 DOWNTO 0 ) := "000100" ; STD_LOGIC _VECTOR ( 5 DOWNTO 0 ) := "001000" ; STD_LOGIC _VECTOR ( 5 DOWNTO 0 ) := "010000" ; STD_LOGIC _VECTOR ( 5 DOWNTO 0 ) := "100000" ;

TABLAS
FIGURAS LISTADOS

ANEXOS

La declaracin en la entidad para la alu (vase Listado 4) define sus entradas de control de tipo STD_LOGIC, a la vez que los vectores de datos y estados tanto de entrada y salida estn definidos como tipos nibble y byte. En la arquitectura behavioral de

arithmetic_logic_unit, una sentencia case selecciona las operaciones de la alu basada en la entrada codificada de seis bits. Las operaciones sumar y restar utilizan las funciones add_cv y sub_cv respectivamente, disponibles en par_utilities. Los bits ms significativos del vector retornado por estas funciones son el sobreflujo y el acarreo de las correspondientes operaciones. A las banderas de salida que no son afectadas por las operaciones de la alu se les asigna los respectivos valores de las banderas de entrada.

16

CONTENIDO

Figura 3. Esquema lgico de la unidad lgico aritmtica

Figura 4. Hardware de 1 de bit de la unidad lgico aritmtica

TABLAS
FIGURAS LISTADOS

ANEXOS

Listado 4. Arithmetic_logic_unit.vhd
ENTITY arithmetic_logic_unit IS PORT (a_side, b_side : IN byte; alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub : IN BIT; in_flags : IN nibble ; z_out : OUT byte ; out_flags : OUT nibble ); END arithmetic_logic_unit; ARCHITECTURE behavioral OF arithmetic_logic_unit IS --seal reg almacena la operacin SIGNAL reg : STD_LOGIC_VECTOR ( 7 DOWNTO 0 ); BEGIN reg <= bit2vector6(alu_sub, alu_b, alu_add, alu_a, alu_not, alu_and); --proceso sensible a las entradas de control coding : PROCESS (a_side, b_side , alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub) VARIABLE t : STD_LOGIC_VECTOR ( 9 DOWNTO 0 ); VARIABLE v, c, z, n : STD_LOGIC; ALIAS n_flag_in : STD_LOGIC IS in_flags(0); ALIAS z_flag_in : STD_LOGIC IS in_flags(1); ALIAS c_flag_in : STD_LOGIC IS in_flags(2); ALIAS v_flag_in : STD_LOGIC IS in_flags(3); BEGIN CASE reg IS

17

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

--operacin (a + b) WHEN a_add_b => t := add_cv (b_side, a_side, c_flag_in); c := (8); v := t(9); --operacin (a - b) WHEN a_sub_b => t := sub_cv (b_side, a_side, c_flag_in); c := t(8); v := t(9); --operacin (a b) WHEN a_and_b => t(7 DOWNTO 0) := a_side AND b_side; c:=c_flag_in; v:=v_flag_in; --operacin (cargar a) WHEN a_input => t(7 DOWNTO 0):=a_side; c:=c_flag_in; v:=v_flag_in; --operacin (cargar b) WHEN b_input => t(7 DOWNTO 0):=b_side; c:=c_flag_in; v:=v_flag_in; --operacin (not b) WHEN b_compl => t(7 DOWNTO 0):= NOT b_side; c:=c_flag_in; v:=v_flag_in; WHEN OTHERS => NULL; END CASE; n: = t(7); z:=set_if_zero(t(7 DOWNTO 0)); z_out <= t (7 DOWNTO 0); out_flags <= x01z2vector4(v, c, z, n); END PROCESS coding; END behavioral;

2.4 UNIDAD DE CORRIMIENTO ( shifter_unit.vhd ) Esta unidad (vase Figura 5) tiene dos lneas para seleccionar el tipo de operacin, corrimiento a la izquierda o a la derecha, cuatro banderas de entrada, ocho lneas de entrada de datos, cuatro banderas de salida y ocho lneas de salida de datos.

Una operacin de corrimiento a la izquierda mueve un 0

hacia la posicin menos

significativa del byte de salida, coloca la entrada corrida en la salida, mueve el bit ms significativo hacia el acarreo de salida y registra los cambios de signo en la bandera de sobreflujo. Una operacin de corrimiento hacia la derecha extiende el bit de signo de la entrada hasta la salida, lo desplaza un lugar hacia la derecha y lo lleva hasta la salida. 18

Ambas operaciones pueden afectar las banderas de zero y negativo.

El cdigo VHDL (vase Listado 5) mediante el cual se implementa la unidad de corrimiento; es una arquitectura determinada por un nico estamento process. Para corrimiento, la concatenacin de operadores es utilizada para el resultado corrido, el cual es asignado a la variable temporal t. Cuando no se especifica alguna de las dos operaciones de corrimiento disponibles, tanto las entradas de datos como las banderas son asignadas a las respectivas salidas de la unidad de corrimiento.

Para el manejo de las banderas se utilizan unas asignaciones a partir del vector de banderas de entradas in_flags mediante una sentencia alias; las banderas que resulten afectadas en las diferentes operaciones son primero actualizadas en los identificadores v, c, z y n. Para
CONTENIDO

finalizar se forma, mediante una funcin predefinida, el vector de banderas out_flags.

TABLAS
FIGURAS LISTADOS

Listado 5. Shifter_unit.vhd
ENTITY shifter_unit IS PORT (alu_side : IN byte ; arith_shift_left , arith_shift_right : IN STD_LOGIC; in_flags : IN nibble ; obus_side : OUT byte ; out_flags : OUT nibble); END shifter_unit; -ARCHITECTURE behavioral OF shifter_unit IS BEGIN CODING : PROCESS (alu_side, arith_shift_left, arith_shift_right) VARIABLE t : STD_LOGIC_VECTOR ( 7 DOWNTO 0); VARIABLE v, c, z, n :BIT; ALIAS n_flag_in : STD_LOGIC IS in_flags(0); ALIAS z_flag_in : STD_LOGIC IS in_flags(1); ALIAS c_flag_in : STD_LOGIC IS in_flags(2); ALIAS v_flag_in : STD_LOGIC IS in_flags(3); BEGIN --no hace corrimientos IF arith_shift_right = '0' AND arith_shift_left = '0' THEN t := alu_side (7 DOWNTO 0); v := v_flag_in; c := c_flag_in; n := n_flag_in; z := z_flag_in; --corrimiento a la izquierda ELSIF arith_shift_left = '1' THEN t := alu_side(6 DOWNTO 0) & '0'; n := t (7); z := set_if_zero(t); c := alu_side(7);

ANEXOS

19

v := alu_side(6) XOR alu_side(7); --corrimiento a la derecha ELSIF arith_shift_right = '1' THEN t := alu_side(7) & alu_side(7 DOWNTO 1); n := t(7); z := set_if_zero(t); c := c_flag_in; v := v_flag_in; END IF; obus_side <= t; out_flags <= bit2vector4(v, c, z, n); END PROCESS CODING; END BEHAVIORAL;

2.5 UNIDAD DE REGISTRO DE ESTADO (status_register_unit.vhd) El registro de estado est conformado por cuatro registros trigger de flanco de bajada de un bit, trabajando de forma sncrona, (vase Figura 6), las entradas load y cm_carry controlan
CONTENIDO

de manera sncrona la entrada de datos a las banderas. Cuando load est activa, todas las cuatro banderas son cargadas en los cuatro flip- flops de banderas, y cuando cm_carry est activa, la bandera c es cargada con el complemento de su valor presente.

TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 5. Esquema lgico de la unidad de corrimiento

Figura 6. Esquema lgico del registro de estado

20

La descripcin del registro de estado en VHDL (vase listado 6), utiliza una declaracin process la cual responde al reloj de entrada. La variable internal_state en la arquitectura behavioral de la unidad del registro de estado mantiene el valor del registro. En el flanco de bajada del reloj, esta variable se asigna al nibble de salida del registro de estado.

Listado 6. Status_register_unit.vhd

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

ENTITY status_register_unit IS PORT ( in_flags : IN nibble ; out_status : OUT nibble; load ,cm_carry , ck : IN STD_LOGIC); END status_register_unit ; -ARCHITECTURE behavioral OF status_register_unit IS BEGIN PROCESS (ck) VARIABLE internal_state : nibble := "0000"; ALIAS internal_c : STD_LOGIC IS internal_state(2); BEGIN IF (ck='0') THEN --cargar registro IF(load='1') THEN internal_state := in_flags; --complementar carry ELSIF (cm_carry='1') THEN internal_c := NOT internal_c; END IF; out_status <= internal_state; END IF; END PROCESS; END behavioral;

2.6 ACUMULADOR ( accumulator_unit.vhd )

El acumulador del procesador (vase Figura 7) es un registro de ocho bits que se puede cargar y resetear de manera sncrona. Un dato externo se carga en el registro durante el flanco de descenso del reloj y cuando las entradas load y zero estn activada y desactivada respectivamente. Una activacin simultanea de ambas entradas; load y zero; limpia el registro. 21

En el cdigo de la arquitectura dataflow del ac (vase listado 7) cuando load est en 1 en el flanco de bajada de ck, se le asigna cero o la entrada i8 a la salida o8 dependiendo de los valores de zero y load.

Listado 7. Accumulator_unit.vhd
ENTITY accumulator_unit IS PORT( i8 : IN byte; o8 : OUT byte; load, zero, ck : IN STD_LOGIC); END accumulator_unit; -ARCHITECTURE dataflow OF accumulator_unit IS BEGIN PROCESS(ck) BEGIN IF FALLING_EDGE(ck) THEN IF zero='1' AND load='1' THEN o8<="00000000"; ELSE o8<=i8; END IF; END IF; END PROCESS; END dataflow;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

2. 7 REGISTRO DE INSTRUCCION (instruction_register_unit.vhd)

El registro de instruccin (ir) es un registro sncrono de ocho bits con una entrada load activa alta (vase Figura 8). La entrada load habilita el reloj y causa que el registro sea cargado durante el flanco de bajada del reloj de entrada (vase Listado 8).

22

CONTENIDO

TABLAS
FIGURAS LISTADOS

Figura 7. Esquema lgico del acumulador

Figura 8. Esquema lgico del registro de instruccin

ANEXOS

Listado 8. Instruction_register_unit.vhd
ENTITY instruction_register_unit IS PORT (i8 : IN byte; o8 : OUT byte; load, ck : IN STD_LOGIC ); END instruction_register_unit; -ARCHITECTURE behavioral OF instruction_register_unit IS BEGIN PROCESS (ck) BEGIN IF FALLING_EDGE(ck) THEN IF load='1' THEN o8 <= i8; END IF; END IF ; END PROCESS; END behavioral;

23

2.8 REGISTRO CONTADOR DE PROGRAMA (program_counter_unit.vhd).

El contador de programa (vase Figura 9) es un contador sncrono ascendente de doce bits con una entrada reset y dos para cargar. La entrada load_page carga a partir de los datos de entrada los cuatro bits ms significativos y load_offset carga los ocho bits menos significativos del registro. La entrada reset reinicia el registro.

El cdigo VHDL del contador de programa (vase listado 9) consiste de un sentencia process que es sensible al reloj de entrada, ck. Este cdigo da la prioridad ms alta a reset, seguido de increment, y finalmente por las entradas load.

La arquitectura behavioral de program_counter_unit permite cargar en el registro de

CONTENIDO

manera simultanea, las partes page y offset. La funcin inc del package basic_utilities realiza el incremento de internal state de esta arquitectura.

TABLAS
FIGURAS

Listado 9. Program_counter_unit.vhd
LISTADOS

ANEXOS

ENTITY program_counter_unit IS PORT ( i12 : IN twelve; o12 : OUT twelve; increment, load_page, load_offset, reset, ck : IN STD_LOGIC); END program_counter_unit; ARCHITECTURE behavioral OF program_counter_unit IS BEGIN PROCESS (ck) VARIABLE internal_state : twelve := zero_12; BEGIN IF (ck='0') THEN --limpiar registro IF reset='1' THEN internal_state:=zero_12; --incrementar registro ELSIF increment='1' THEN internal_state:=inc(internal_state) ; ELSE IF load_page='1' THEN --cargar direccin de segmento (page) internal_state(11 DOWNTO 8) := i12(11 DOWNTO 8); END IF; IF load_offset='1' THEN --cargar direccin de desplazamiento (offset) internal_state(7 DOWNTO 0) := i12(7 DOWNTO 0); END IF;

24

END IF; o12 <= internal_state; END IF; END PROCESS; END behavioral;

2.9 REGISTRO

DE

DIRECCIONAMIENTO

DE

MEMORIA

(memoty_address_register_unit.vhd) El registro de direccionamiento de memoria (mar) es un registro de 12 bits con dos entradas para cargar de forma sncrona (vase Figura 10). La entrada load_page carga en paralelo el nibble
CONTENIDO

ms significativo el registro, y load_offset carga el dato en el byte menos

significativo.
TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 9. Esquema lgico del registro contador de programa 25

Figura 10. Esquema lgico del Registro de direccionamiento de memoria

El cdigo VHDL del mar (vase listado 10) es una sentencia process la cual es sensible a los eventos de la seal ck constituye la sentencia principal de la arquitectura behavioral de la memory_address_register_unit. La sentencia if en la rutina principal permite cargar La variable internal_state que mantiene los

simultneamente las partes page y offset

contenidos del registro es asignada a la salida de esta unidad en cada flanco de bajada del reloj.

Listado 10. Memory_address_register_unit.vhd

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

ENTITY memory_address_register_unit IS PORT ( i12 : IN twelve; o12 : OUT twelve; load_page, load_offset, ck : IN STD_LOGIC ); END memory_address_register_unit; -ARCHITECTURE behavioral OF memory_address_register_unit IS BEGIN PROCESS (ck) VARIABLE internal_state : twelve := zero_12; BEGIN IF FALLING_EDGE(ck) THEN --cargar direccin de segmento (page) IF load_page='1' THEN internal_state(11 DOWNTO 8) := i12(11 DOWNTO 8); END IF; --cargar direccin de desplazamiento (offset) IF load_offset='1' THEN internal_state(7 DOWNTO 0) := i12(7 DOWNTO 0); END IF; o12 <= internal_state; END IF; END PROCESS; END behavioral;

26

2.10

TRANSFERENCIA DE DATOS ENTRE REGISTROS (par_data_path.vhd)

Esta entidad (vase listado 11) define la interconexin de componentes elementales del procesador para que los datos circulen entre estos a travs del sistema de buses e interconexiones condicionados por las seales provenientes de la unidad de control. Un nombre de una seal de control para un registro se forma anteponiendo al nombre del registro, el nombre de la seal del registro. Por ejemplo, la entrada load_page_mar de par_data_path se conecta a la entrada load_page del mar o Registro de Direccionamiento de Memoria. Un nombre de una seal de conexin de bus est formado por el nombre de la fuente del bus, seguido de la palabra on y luego del nombre del bus, ejemplo: mar_on_adbus.

CONTENIDO

Listado 11. Entidad par_data_path

ENTITY par_data_path IS PORT (databus : Adbus : clk : --Seales para control de registros load_ac, zero_ac, load_ir, increment_pc, load_page_pc, load_offset_pc, reset_pc, load_page_mar, load_offset_mar, load_sr, cm_carry_sr, --Seales para conexin de buses pc_on_mar_page_bus, ir_on_mar_page_bus, pc_on_mar_offset_bus, dbus_on_mar_offset_bus, pc_offset_on_dbus, obus_on_dbus, databus_on_dbus, mar_on_adbus, dbus_on_databus, --Seales para control e unidad lgico aritmtica arith_shift_left, arith_shift_right, alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub --Salidas hacia la unidad de control ir_lines status END par_data_path; IN byte BUS; OUT twelve; IN STD_LOGIC;

TABLAS
FIGURAS LISTADOS

ANEXOS

: IN

STD_LOGIC ;

: OUT byte; : OUT nibble);

La arquitectura structural de par_data_path componentes.

(vase Listado 12) usa llamadas de

27

Listado 12. Declaracin de componentes y seales de par_data_path

ARCHITECTURE structural OF par_data_path IS --llamado del acumulador COMPONENT accumulator_unit PORT ( i8 : IN byte; o8 : OUT byte; load, zero, ck : IN STD_LOGIC); END COMPONENT; --llamado del registro de instruccin COMPONENT instruction_register_unitc PORT (i8 : IN byte; o8 : OUT byte; load, ck : IN STD_LOGIC); END COMPONENT; --llamado del registro contador de programa COMPONENT program_counter_unit PORT (i12 : IN twelve; o12 : OUT twelve; increment, load_page, load_offset, res et, ck : IN STD_LOGIC); END COMPONENT; --llamado del registro de direccionamiento de memoria COMPONENT memory_address_register_unit PORT (i12 : IN twelve; o12 : OUT twelve; load_page, load_offset, ck : IN STD_LOGIC); END COMPONENT; --llamado del registro de estado COMPONENT status_register_unit PORT(in_flags : IN nibble; out_status : OUT nibble; load, cm_carry, ck : IN STD_LOGIC); END COMPONENT; --llamado de la unidad lgico aritmtica COMPONENT arithmetic_logic_unit PORT(a_side, b_side : IN byte; alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub : IN STD_LOGIC; in_flags : IN nibble; z_out : OUT byte; out_flags : OUT nibble); END COMPONENT; --llamado de la unidad de corrimiento COMPONENT shifter_unit PORT(alu_side : IN byte; arith_shift_left, arith_shift_right : IN STD_LOGIC; in_flags : IN nibble; obus_side : OUT byte; out_flags : OUT nibble); END COMPONENT; -- seales intermedias SIGNAL ac_out, ir_out, alu_out, obus, alu_a_inp : byte; SIGNAL pc_out, mar_out : twelve; SIGNAL dbus : byte BUS; SIGNAL alu_flags, shu_flags, sr_out : nibble; SIGNAL mar_bus : twelve BUS; SIGNAL mar_inp : twelve;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

La arquitectura Structural utiliza sentencias process, controladas por los puertos de entrada provenientes de LA UNIDAD DE CONTROL, estas sentencias deben agrupar las transferencias de datos que tengan como destino una misma seal (vase Listado 13), con el fin de no cometer errores de mltiple asignacin. 28

Listado 13. Asignacin de seales de par_data_path

BEGIN --conexin entre buses dbus1 :alu_a_inp <= dbus; coding1 : PROCESS(dbus_on_databus, obus_on_dbus, databus_on_dbus, pc_offset_on_dbus) BEGIN IF dbus_on_databus='1' THEN databus <= dbus; IF obus_on_dbus='1' THEN dbus <= obus; IF databus_on_dbus='1' THEN dbus <= databus; IF pc_offset_on_dbus='1' THEN dbus <= pc_out(7 DOWNTO 0); END PROCESS coding1; -mar_bus1:mar_inp <= mar_bus;

END IF; END IF; END IF; END IF;

CONTENIDO

TABLAS
FIGURAS LISTADOS

--conexin de registros r1:accumulator_unit PORT MAP (obus, ac_out, load_ac, zero_ac, clk); -r2:instruction_register_unit PORT MAP(obus, ir_out, load_ir, clk); ir1:ir_lines <= ir_out; -r3:program_counter_unit PORT MAP(mar_out,pc_out, increment_pc, load_page_pc, load_offset_pc, reset_pc, clk); --cargar mar con datos desde pc coding2:PROCESS(ir_on_mar_page_bus, pc_on_mar_page_bus, pc_on_mar_offset_bus, dbus_on_mar_offset_bus) BEGIN IF ir_on_mar_page_bus='1' THEN mar_bus(11 DOWNTO 8)<=ir_out(3 DOWNTO 0); END IF; IF pc_on_mar_offset_bus='1' THEN mar_bus(7 DOWNTO 0) <= pc_out(7 DOWNTO 0); END IF; IF dbus_on_mar_offset_bus='1' THEN mar_bus(7 DOWNTO 0)<=dbus; END IF; IF pc_on_mar_page_bus='1' THEN mar_bus(11 DOWNTO 8)<=pc_out(11 DOWNTO 8); END IF; END PROCESS coding2; -r4:memory_address_register_unit PORT MAP(mar_inp, mar_out, load_page_mar, load_offset_mar, clk); --cargar adbus para direccionar memoria coding3 : PROCESS(mar_on_adbus) BEGIN IF mar_on_adbus='1' THEN adbus <= mar_out; END IF; END PROCESS coding3;

ANEXOS

29

-r5:status_register_unit PORT MAP(shu_flags, sr_out, load_sr, cm_carry_sr, clk); sr1: status<=sr_out; l1:arithmetic_logic_unit PORT MAP(alu_a_inp, ac_out, alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub, sr_out, alu_out, alu_flags); l2:shifter_unit PORT MAP(alu_out, arith_shift_left, arith_shift_right, alu_flags, obus, shu_flags); END structural;

2.11 SIMULACION UNIDAD DE CONTROL (control_unit.vhd)

La unidad de control como ya se mencion es una mquina de estados, 26 en total, que

CONTENIDO

afecta diferentes seales de control para determinar los movimientos de informacin a travs de los diferentes componentes, los valores de estas seales de control estn

TABLAS
FIGURAS LISTADOS

determinados por la entrada status (nibble) y en especial por ir_lines (byte) provenientes de la ESTRUCTURA DE BUSES y que contienen el registro de banderas y de instruccin respectivamente.

ANEXOS

En el listado 14 se tiene la entidad control_unit, para obtener una descripcin mas detallada y la arquitectura dataflow (vase Anexo A).

Listado 14. Entidad par_control_unit.

ENTITY control_unit IS PORT ( clk, interrupt : IN STD_LOGIC; --Entradas de la seccin de buses ir_lines : IN byte; status : IN nibble; --Seales de control de registros load_ac, zero_ac, load_ir, increment_pc, load_page_pc, load_offset_pc, reset_pc, load_page_mar, load_offset_mar, load_sr, cm_carry_sr,

30

--Seales de control de buses pc_on_mar_page_bus, ir_on_mar_page_bus, pc_on_mar_offset_bus, dbus_on_mar_offset_bus, pc_offset_on_dbus, obus_on_dbus, databus_on_dbus, mar_on_adbus, dbus_on_databus, --Salidas de control ALU arith_shift_left, arith_shift_right, alu_and, alu_not, alu_a, alu_add, alu_b, alu_sub, --Seales de control de memoria read_mem, write_mem : OUT STD_LOGIC); END control_unit;

2.12 INTERCONEXION DE BUSES Y UNIDAD DE CONTROL

CONTENIDO

TABLAS
FIGURAS LISTADOS

El diseo completo del procesador consiste de las entidades par_data_path (seccin 2.6) y control_unit (seccin 2.7), la entidad par_central_processing_unit determina la

interconexin de la arquitectura structural de par_data_path y dataflow de control_unit; los nombres de seales y puertos omitidos en el listado 15 corresponden a los mismos usados en los listados 11 y 14.
ANEXOS

Listado 15. par_central_processing_unit.vhd

ENTITY par_central_processing_unit IS PORT( clk, interrupt : IN STD_LOGIC; read_mem, write_mem : OUT STD_LOGIC; databus : IN byte; adbus : OUT twelve; ); END par_central_processing_unit; -ARCHITECTURE dataflow OF par_central_processing_unit IS --declaracin de ESTRUCTURA DE BUSES COMPONENT par_data_path PORT(databus : IN byte; adbus : OUT twelve; clk : IN STD_LOGIC; . . . . ir_lines : OUT byte;

31

status read_mem ); END COMPONENT; --declaracin de UNIDAD DE CONTROL COMPONENT control_unit PORT ( clk, interrupt . . . load_ac, zero_ac, load_ir, read_mem, write_mem END COMPONENT; -SIGNAL --Seales de control de registros load_ac, zero_ac, . . . SIGNAL ir_lines : byte; SIGNAL status : nibble; -BEGIN --Estructura de buses data:par_data_pathc PORT MAP (databus, adbus, clk, . . . . ir_lines, status, ); --Unidad de control ctrl:control_unit PORT MAP ( clk, interrupt, . . . read_mem, write_mem ); END dataflow;

: OUT nibble; : OUT STD_LOGIC

: IN

STD_LOGIC;

: OUT STD_LOGIC);

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

32

3. RESULTADOS

A continuacin se

presenta la ejecucin de un programa, que ejecuta diez de las

instrucciones ms representativas. Se ilustran mediante diagramas de tiempo: la transicin de estados de la unidad de control (state), la seal de reloj (clock), el valor de los registros ac, ir y pc, y si es de inters para una instruccin en particular el contenido de las unidades combinacionales alu y shu, y del bus de datos dbus, representado por la seal datos.

Los nombres que toma state, representa los diferentes estados de la UNIDAD DE
CONTENIDO

CONTROL, inician con la letra s seguida de un numero que representa la secuencia de estados, as por ejemplo, el estado inicial es s1, seguido de s2; tambin se representan subestados como s63 que identifica al subestado 3 del estado 6 y cuya ocurrencia depende de la instruccin a ejecutar.

TABLAS
FIGURAS LISTADOS

ANEXOS

Para programar y ver los resultados en el editor de onda se debe compilar y simular la entidad parwan_tester.vhd (vase listado 16) la cual hace un llamado de la UNIDAD CENTRAL DE PROCESAMIENTO (par_central_processing_unit.vhd) que devuelve la seal de control read_mem.

Listado 16. Parwan_tester.vhd

ENTITY parwan_tester IS PORT( clock : IN STD_LOGIC; interrupt : IN STD_LOGIC; ); END parwan_testerc; -ARCHITECTURE input_output OF parwan_testerc IS

33

--llamado a la UNIDAD CENTRAL DE PROCESAMIENTO COMPONENT par_central_processing_unit PORT ( clk, interrupt : IN read_mem, write_mem : OUT databus : IN adbus : OUT ); END COMPONENT; --seales intermedias SIGNAL read, write SIGNAL address, datos SIGNAL address1 SIGNAL ia

STD_LOGIC; STD_LOGIC; byte ; twelve

: STD_LOGIC; : byte; : UNSIGNED ( 11 DOWNTO 0 ); : INTEGER;

--Arquitectura BEGIN Cpu:par_central_processing_unit PORT MAP (clock , interrupt, read, write, datos, address); --convertir direccion de twelve a integer, a travs de unsigned address1 <= UNSIGNED(address); ia <= CONV_INTEGER(address1); leer <= read; -PROCESS (clock) BEGIN IF FALLING_EDGE(clock) THEN --cuando read = 1 lee la memoria IF read='1' THEN datos <= instruccion(ia); END IF; END IF; END PROCESS; -END input_output;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

Cuando read_mem tiene valor 1 hace un llamado al paquete instruccin.vhd (vase listado 17) el cual hace las veces de memoria externa. A cada direccin de entrada de tipo entero, este retorna un vector de tipo byte como instruccin o dato, el cual es recibido por la seal datos. Esta seal es un parmetro de entrada de la UNIDAD CENTRAL DE

PROCESAMIENTO.

34

Listado 17. Instruccion.vhd

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

PACKAGE instruccion IS FUNCTION instruccion(a : INTEG ER) RETURN STD_LOGIC_VECTOR; END instruccion; -PACKAGE BODY instruccion IS FUNCTION instruccion(a : INTEGER) RETURN STD_LOGIC_VECTOR IS VARIABLE result : STD_LOGIC_VECTOR (7 DOWNTO 0); BEGIN --Se dan valores nicamente a las direcciones utilizadas en el programa, para las demas retorna 0 IF a=0 THEN result := "00010000" ; ElSIF a=1 THEN result := "00001000" ; --lda !8 ELSIF a=2 THEN result := "01100000" ; ELSIF a=3 THEN result := "00000110" ; --sub 6 ELSIF a=4 THEN result := "10000000" ; ELSIF a=5 THEN result := "00001001" ; --jmp 9 ELSIF a=6 THEN result := "00001111" ; --Contiene dato= 15 ELSIF a=7 THEN result := "11110000" ; --Contiene dato=240 ELSIF a=8 THEN result := "00000111" ; --Apunta a 7 ELSIF a=9 THEN result := "11100000" ; --nop ELSIF a=10 THEN result := "11100010" ; --cac ELSIF a=11 THEN result := "11101000" ; --asl ELSIF a=12 THEN result := "11100100" ; --cmc ELSIF a=13 THEN result := "11110100" ; ELSIF a=14 THEN result := "00010100" ; --branch_c 20 ELSIF a=20 THEN result := "00110000" ; ELSIF a=21 THEN result := "00011001" ; --And, i 25 ELSIF a=22 THEN result := "11100001" ; --cla ELSIF a=24 THEN result := "01011100" ; ELSIF a=25 THEN result := "00101000" ; --Apunta a 40 ELSIF a=40 THEN result := "01010101" ; ELSE result := "00000000" ; END IF; RETURN result; END instruccion; -END instruccion;

En la simulacin se emple como perodo de reloj un intervalo de 200 ns lo que representa una frecuencia de 5 MHz, adems se trabajar en el primer segmento de memoria (pc_page=0000, primeros 255 bytes de memoria) y el valor inicial del pc_offset es de 00000000 lo que nos garantiza que la primera instruccin ser ejecutada desde la posicin 0.

35

El programa de prueba ejecuta diez instrucciones (vase Tabla 4). La columna BYTE determina la posicin de memoria que contiene la instruccin a ejecutar cuando son instrucciones de un solo byte o el primero de dos cuando son instrucciones de dos bytes; la columna B/I indica el nmero de bytes que componen la instruccin; la columna

INSTRUCCIN representa el nemnico de la instruccin, es importante sealar que los operandos de las instrucciones de dos bytes precedidos por la letra i indican que se ejecutan en modo de direccionamiento indirecto, por ltimo la columna COMENTARIO ofrece una breve descripcin de la instruccin.

Tabla 4. Programa de prueba

BYTE B / I (*) INSTRUCCION 2 2 2 1 1 1 1 2 2 1 Lda , i 8 Sub 6 Jmp 9 Nop Cac Asl Cmc Branch_c 20 And , i 25 Cla COMENTARIO Cargar ac con dato donde apunta direccin 8 Restar a ac el dato contenido en la direccin 6 Ejecutar como prxima instruccin la direccin 9 Ninguna operacin Complementar ac Realizar corrimiento a la izquierda de ac Complementar acarreo c Si c=1 ejecutar como prxima instruccin la direccin 20 Operacin AND entre ac y dato donde apunte direccin 25 Limpiar ac 0 2

CONTENIDO

TABLAS
FIGURAS LISTADOS

4 9 10 11

ANEXOS

12 13 20 22

(*)Nmero de bytes por instruccin

Los valores de tipo byte que se cargan en la memoria y representan instrucciones se pueden consultar en la Tabla 2. Los valores que representen datos (direcciones u operandos) empleados en el programa se indican en la Tabla 5. La columna POSICIN EN

MEMORIA indica el nmero de byte que ocupa en la memoria; la segunda y tercera columna como su nombre lo indica representan el VALOR BINARIO y VALOR DECIMAL del dato, finalmente FUNCION determina si el dato es una direccin de otra posicin de memoria o si es un operando. A medida que se vayan desarrollando las instrucciones se explicar ms al respecto. 36

La primera instruccin (lda , i8) (vsae Figura 11), carga en ac el valor al que apunta la direccin contenida en la posicin 8, que en este caso es 7 y que a su vez contiene el valor a cargar (240). State representa la transicin de estados de la unidad de control, en este caso el estado inicial es s1 y el final s631, el cual arroja el resultado esperado como se observa en el contenido de ac, presto a iniciar otro ciclo de mquina.

Tabla 5. Valores de datos ( direcciones u operandos) en memoria

POSICIN EN MEMORIA VALOR BINARIO 1 3 5 6 00001000 00000110 00001001 00001111 11110000 00000111 00010100 00011001 00101000 01010101 VALOR DECIMAL 8 6 9 15 240 7 20 25 40 85 FUNCION Direccin Direccin Direccin Operando Operando Direccin Direccin Direccin Direccin Operando

CONTENIDO

7 8 14

TABLAS
FIGURAS LISTADOS

21 25 40

ANEXOS

El contenido de ir a partir del estado s3 es la instruccin a ejecutar; pc se inicia en 0 y comienza el otro ciclo en el valor 2 para direccionar la prxima instruccin.

Figura 11. Diagrama de tiempo de la instruccin lda i8

37

Para la segunda instruccin (sub 6) que empieza en el byte nmero 2 al contenido de ac (240) se le resta el valor (15), contenido en la posicin de memoria 6 y presente en datos despus del estado s63. El resultado (225) se carga en el ac durante el estado s634 (vase Figura 12).

CONTENIDO

TABLAS
FIGURAS LISTADOS

Figura 12. Diagrama de tiempo de la instruccin sub 6

ANEXOS

La ejecucin de ( jmp 9) (vase Figura 13) donde es de resaltar que el contenido de ac no se altera, pero si el de pc durante el estado s61, lo que determina que la prxima instruccin a ejecutar sea la contenida en la posicin 9.

Figura 13. Diagrama de tiempo de la instruccin jmp 9

38

La instruccin de la posicin 9 corresponde a (nop) para no realizar operacin alguna, incrementa pc (estado s3) para dar lectura a la prxima instruccin (cac) (vase Figura 14) localizada en la siguiente posicin de memoria, en este ejemplo, posicin 10 cuya finalidad es complementar ac como ocurre en el estado s32 y se observa en la seal alu, en formato decimal (el complemento a uno de 225 es 30). Finalmente el resultado se carga en ac durante el estado s321.

CONTENIDO

TABLAS
FIGURAS LISTADOS

Figura 14. Diagrama de tiempo de las instrucciones nop y cac

ANEXOS

La sexta instruccin del programa (asl) realiza una operacin de corrimiento aritmtico a la izquierda del contenido de ac, asl reside en la posicin de memoria nmero 11, direccin cargada en pc desde la instruccin anterior; asl transcurre a travs de un total de cuatro estados de mquina de la UNIDAD DE CONTROL empezando en s2, haciendo transicin por s3 y s32, hasta llegar finalmente a s322 donde se carga nuevamente ac con el resultado, proveniente de la unidad de corrimiento (shu) , como se ilustra en la Figura 15.

Figura 15. Diagrama de tiempo de la instruccin asl 39

La instruccin cmc; residente en la posicin 13 como lo indica pc; despus de cuatro estados en los cuales no se altera el contenido de ac complementa la bandera de acarreo (c) del registro de estado y observable en la figura 16 como la seal hc:data!status(2) (de hc:data!status(3 downto 0)).

CONTENIDO

TABLAS
FIGURAS LISTADOS

Figura 16. Diagrama de tiempo de la instruccin cmc

La figura 17 permite observar como el valor de pc corresponde a 20, al iniciar el estado s1 de la siguiente instruccin y como consecuencia de que el valor de la bandera de acarreo en el registro de banderas status es 1, tal cual lo dispone la ejecucin de la instruccin branch_c 20. El contenido de ac no se altera.

ANEXOS

Figura 17. Diagrama de tiempo de la instruccin branch_c 20

La penltima instruccin ( nd , i 25) ubicada en la posicin 20, utiliza un operando a direccionado en modo indirecto para realizar la operacin AND bit a bit con el contenido 40

de ac.

Para el ejemplo la direccin contenida en el segundo byte de la instruccin

(posicin 21) apunta a la direccin 25, la que a su vez apunta a la direccin 40 como se observa en el valor del mar desde el estado s41

El valor de la posicin de memoria 40 (vase Tabla 6), es cargado en la seal datos durante el estado s63 y los valores inicial y final de ac utilizados en el ejemplo. El resultado es cargado en ac durante el estado s632 como se aprecia en la figura 18.

Tabla 6. Valores de operacin and Valor inicial ac 00111100

Valor posicin 40 ( operando ) 0 1 0 1 0 1 0 1

CONTENIDO

Valor final ac ( resultado )

00010100

TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 18. Diagrama de tiempo de la instruccin and , i 25.

Finalmente se ejecuta la instruccin cla, cuyo propsito es limpiar el contenido de ac, como ocurre en el estado s325 (vase Figura 19).

41

Figura 19. Diagrama de tiempo de la instruccin cla.

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

42

CONCLUSIONES

La metodologa de diseo descendente representa grandes ventajas en el diseo de circuitos digitales complejos como el de un procesador, porque ofrece una descripcin estructurada en subsistemas ms pequeos, haciendo uso adecuado de los niveles de abstraccin en las diferentes etapas del diseo. Adems permite la verificacin de resultados en cada fase del proyecto permitiendo descubrir fallas, para facilitar de este modo las correcciones necesarias.
CONTENIDO

TABLAS
FIGURAS LISTADOS

El lenguaje de descripcin de hardware VHDL es la mejor alternativa en la simulacin de circuitos digitales, dejando atrs dificultades como la complejidad para el usuario, ofrecidas por las herramientas CAD tradicionales, ampliamente difundidas y utilizadas en el diseo de circuitos analgicos.

ANEXOS

El lenguaje VHDL utilizado en las herramientas de sntesis, difiere del utilizado por las herramientas orientadas a la simulacin porque impone restricciones sintcticas y semnticas, como, por ejemplo, los retardos. Por este motivo los diseos, especialmente los de simulacin deben ser ajustados para su correcto funcionamiento en las herramientas de sntesis.

La simulacin del procesador constituye un trabajo de alto inters pedaggico porque representa un estudio de algunas de las arquitecturas digitales de mediana integracin ms representativas en la formacin de un ingeniero electrnico y porque utiliza la metodologa y herramientas de diseo, aunque guardando las diferencias, de las aplicaciones comerciales.

43

La ayuda al usuario del programa de sntesis de circuitos Max Plus II no es muy didctica, especialmente porque es pobre en ejemplos y pretende hacer una descripcin muy abstracta de cada instruccin. La anterior situacin es compensada con la amplia documentacin que existe sobre diseos en VHDL, principalmente en Internet, y que constituyen un soporte para el diseador principiante.

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

44

BIBLIOGRAFIA

VHDL Anlisis and Modeling of Digital Systems Zainalabedin Navabi, McGraw-Hill, Segunda Edicin, 1998.

ALTERA MAX + PLUS VHDL (Manuales) http://www.altera.com/literature/lit- index.html Altera Corporation, 1996.
CONTENIDO

TABLAS
FIGURAS LISTADOS

VHDL Lenguaje estndar de diseo electrnico Lluis Ters, Yago Torroja, Serafn Olcoz, Eugenio Villar McGraw-Hill / Interamericana de Espaa. 1998.

ANEXOS

45

ANEXO A. Unidad de Control

Consiste en una mquina de estados, 26 en total extrada de la plantilla del Max+plus II, donde cada uno de ellos acta sobre algunas de las 30 seales de control por exactamente un perodo de reloj, estas seales son enviadas a la ESTRUCTURA DE BUSES y determinan el flujo de datos por los diferentes registros, elementos combinacionales y memoria externa que componen el sistema, y a su vez recibe de la estructura un vector de datos y uno de banderas, que determinan la transicin de estados de acuerdo a la instruccin a ejecutar. La entidad control_unit (vase capitulo 3. listado 14) define dos entradas clk e
CONTENIDO

interrupt correspondientes a la seal de reloj y de interrupcin respectivamente.

TABLAS
FIGURAS LISTADOS

La duracin de cada estado es de un perodo de reloj, la mquina presenta nueve estados fundamentales y quince subestados secundarios cuya ocurrencia depende de la instruccin a ejecutar contenida en ir y proveniente de la ESTRUCTURA DE BUSES bajo

ANEXOS

el nombre de ir_lines.

El listado 18 ilustra la secuencia de estados, una sentencia process controlada por clk determina que la transicin entre estados se realice durante el flanco de subida del reloj. La sentencia case determina para cada uno de los estados cual es el estado siguiente, la seal state del tipo STATE_TYPE contiene el valor del estado actual. Listado 18. Secuencia de estados (s1-s3) de par_control_unit.vhd
ARCHITECTURE dataflow OF control_unit IS TYPE STATE_TYPE IS (s1, s2, s3, s32, s321, s322, s323, s324, s325, s4, s41, s42, s5, s51, s6, S61, s62, s63, s631, s632, s633, s634, s7, s8, s9, s91); SIGNAL state : STATE_TYPE; BEGIN PROCESS (clk) BEGIN IF interrupt = '1' THEN state <= s1;

46

ELSIF clk'EVENT AND clk='1' THEN CASE state IS --Estado 1 WHEN s1 => IF interrupt='0' ELSE state <= s1; END IF; --Estado 2 WHEN s2 => IF clk='0' THEN --Estado 3 WHEN s3 => IF ir_lines(7 DOWNTO 4)/="1110" THEN state <= s4; ELSIF ir_lines(7 DOWNTO 4)="1110" THEN state <= s32; END IF; WHEN s32 => IF ir_lines(1)='1' THEN state <= s321; ELSIF ir_lines(3 DOWNTO 0)="1000" THEN state <= s322; ELSIF ir_lines(3 DOWNTO 0)="1001" THEN state <= s323; ELSIF ir_lines(2)='1' THEN state <= s324; ELSIF ((ir_lines(3)='0') AND (ir_lines(0)='1')) THEN state <= s325; ELSE state <= s2; END IF; WHEN s321 => IF clk='0' THEN state <=s2; END IF; WHEN s322 => IF clk='0' THEN state <=s2; END IF; WHEN s323 => IF clk='0' THEN state <=s2; END IF; WHEN s324 => IF clk='0' THEN state <=s2; END IF; WHEN s325 => IF clk='0' THEN state <=s2; END IF; state <=s3; END IF; THEN state <= s2;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

Desde el estado inicial s1 hasta s3 la transicin no est condicionada por ninguna seal de entrada. Al llegar a s3 los valores de ir_lines descendiendo desde la posicin siete hasta la cuatro (ir_lines(7 DOWNTO 4)) determinan si la instruccin esta compuesta por uno 47

(excepto BRANCH ) o dos bytes (vase tabla 2); si es de dos bytes (ir_lines(7 DOWNTO 4)/=1110) se hace la transicin al estado s4, en caso contrario hacia el subestado s32.

Cada uno de los subestados s321, s322, s323, s324 y s325 derivados de s32, activan las correspondientes seales de control (vase tabla 7) de tal modo que permitan la ejecucin de la instruccin asociada. El siguiente estado es s2.

El estado s4 (vase listado 18) tiene dos subestados: s41 para cargar el segmento desde ir si las instrucciones no son BRANCH o JSR y s42 que sirve como transicin hacia los estados s7 o s9 para ejecutar BRANCH y JSR respectivamente.

CONTENIDO

Tabla 7. Seales afectadas por instrucciones de un byte SUBESTADO SEALES AFECTADAS s321 alu_not, alu_b, load_ac, load_sr s322 arith_shift_left, load_ac, load_sr s323 arith_shift_right, load_ac, load_sr s324 cm_carry_sr s325 zero_ac INSTRUCCION ASOCIADA CMA ASL ASR CMC CLA

TABLAS
FIGURAS LISTADOS

ANEXOS

Listado 18. Estado s4 de par_control_unit.vhd

--Estado 4 WHEN s4 => IF ir_lines(7 DOWNTO 6)/="11" THEN ELSIF ir_lines(7 DOWNTO 6) = "11" THEN END IF; WHEN s41 => IF i r_lines(4)='1' THEN ELSIF ir_lines(4)='0' THEN END IF; WHEN s42 => IF ir_lines(5)='1' THEN ELSIF ir_lines(5)='0' THEN END IF;

state <= s41; state <= s42;

state <= s5; state <= s6;

state <= s9; state <= s7;

Desde el estado s41 se continua con el estado s5 o s6, dependiendo del modo de direccionamiento, indirecto (ir_lines(4)=1) o indirecto (ir_lines(4)=0) respectivamente. 48

Los estados s5 y s51 (vase listado 19), intermedios entre s41 y s6, sirven para hacer un direccionamiento adicional cuando se trabaja en modo indirecto para. El estado s6 y sus subestados (vase listado 19) afectan las seales necesarias que permitan manipular el operando de la instruccin a ejecutar como se pude ver en la tabla 7. Listado 19. Secuencia de estados (s5-s6) de control_unit.vhd
--Estado 5 WHEN s5 => IF clk='0' THEN state <=s51; END IF; WHEN s51 => IF clk='0' THEN state <=s6; END IF; --Estado 6 WHEN s6 => IF ir_lines(7 DOWNTO 5)="100" THEN state <= S61; ELSIF ir_lines(7 DOWNTO 5)="101" THEN state <= s62; ELSIF ir_lines(7)='0' THEN state <= s63; END IF; WHEN s61 => IF clk='0' THEN state <= s2; END IF; WHEN s62 => IF clk='0' THEN state <= s1; END IF; WHEN s63 => IF ir_lines(6 DOWNTO 5)="00" THEN state <= s631; ELSIF ir_lines(6 DOWNTO 5)="01" THEN state <= s632; ELSIF ir_lines(6 DOWNTO 5)="10" THEN state <= s633; ELSIF ir_lines(6 DOWNTO 5)="11" THEN state <= s634; END IF; WHEN s631 => IF clk='0' THEN state <=s1; END IF; WHEN s632 => IF clk='0' THEN state <= s1; END IF; WHEN s633 => IF clk='0' THEN state <= s1; END IF; WHEN s634 => IF clk='0' THEN state <= s1; END IF;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

Tabla 8. Seales afectadas por instrucciones de dos bytes SUBESTADO s631 s632 s633 s634 SEALES AFECTADAS alu_a alu_and alu_add alu_sub INSTRUCCION ASOCIADA LDA, JMP AND ADD SUB

La secuencia de los ltimos estados (vase listado 20) empieza en s7 (instruccin JSR), continua en s8 (instrucciones BRANCH_) y concluye en s9. 49 En caso de no realizar

operacin alguna (instruccin NOP) hace transicin en s91 para reiniciar la prxima instruccin en s1. Listado 20. Secuencia de estados (s7-s9) de par_control_unit.vhd
--Estado 7 WHEN s7 => IF clk='0' THEN state <= s8; END IF; --Estado 8 WHEN s8 => IF clk='0' THEN state <= s1; END IF; --Estado 9 WHEN s9 => IF ((status AND ir_lines(3 DOWNTO 0))/="0000") THEN state <= s91; ELSE state <= s1; END IF; WHEN s91 => IF clk='0' THEN state <= s1; END IF; END CASE; END IF; END PROCESS;

CONTENIDO

TABLAS
FIGURAS LISTADOS

Cada estado de la UNIDAD DE CONTROL afecta las seales de control necesarias para la transferencia de datos entre los diferentes componentes que permitan la correcta ejecucin de las instrucciones. Esta asignacin se hace como se muestra en el listado 21.

ANEXOS

Listado 21. Asignacin de seales de par_control_unit.vhd

--seales de control de registros WITH state SELECT load_ac <= '1' WHEN s631, '1' WHEN s632, '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, '1' WHEN s325, '1' WHEN s633, '1' WHEN s634, '0' WHEN OTHERS; WITH state SELECT zero_ac <= '1' WHEN s325, '0' WHEN OTHERS; WITH state SELECT load_ir <= '1' WHEN s2, '1' WHEN s3, '1' WHEN s4, '0' WHEN OTHERS; WITH state SELECT increment_pc <= '1' WHEN s2, '1' WHEN s631, '1' WHEN s632, '1' WHEN s633, '1' WHEN s634, '1' WHEN s42, '1' WHEN s8, '0' WHEN OTHERS; WITH state SELECT load_page_pc <= '1' WHEN s61, '0' WHEN OTHERS; WITH state SELECT load_offset_pc <= 1' WHEN s61, '1' WHEN s7, '1' WHEN s91, '0' WHEN OTHERS; WITH state SELECT reset_pc <= interrupt WHEN s1, '0' WHEN OTHERS; WITH state SELECT

50

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

load_page_mar <= '1' WHEN s1, '1' WHEN s3, '1' WHEN s32, '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, '1' WHEN s324, '1' WHEN s325, '1' WHEN s41, '0' WHEN OTHERS; WITH state SELECT load_offset_mar <= '1' WHEN s1, '1' WHEN s3, '1' WHEN s32, '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, ' 1' WHEN s324, '1' WHEN s325, '1' WHEN s4, ' 1' WHEN s41, '1' WHEN s42, '1' WHEN s5, 1' WHEN s51, '0' WHEN OTHERS; WITH state SELECT load_sr <= '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, '1' WHEN s63, '1' WHEN s631, '1' WHEN s632, '1' WHEN s634, '0' WHEN OTHERS; WITH state SELECT cm_carry_sr <= '1' WHEN s324, '0' WHEN OTHERS; --Seales de control de buses WITH state SELECT pc_on_mar_page_bus <= '1' WHEN s1, '1' WHEN s3, '1' WHEN s32, '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, '1' WHEN s324, '0' WHEN OTHERS; WITH state SELECT ir_on_mar_page_bus <= '1' WHEN s41, '0' WHEN OTHERS; WITH state SELECT pc_on_mar_offset_bus <= '1' WHEN s1, '1' WHEN s3, '1' WHEN s32, '1' WHEN s321, '1' WHEN s322, '1' WHEN s323, '1' WHEN s324, '1' WHEN s325, '0' WHEN OTHERS; WITH state SELECT dbus_on_mar_offset_bus <= '1' WHEN s4, '1' WHEN s41, '1' WHEN s42, 1' WHEN s5, '0' WHEN OTHERS; WITH state SELECT pc_offset_on_dbus <= '1' WHEN s7, '0' WHEN OTHERS; WITH state SELECT obus_on_dbus <= '1' WHEN s62, '0' WHEN OTHERS; WITH state SELECT databus_on_dbus <= '1' WHEN s2, '1' WHEN s4, '1' WHEN s41, '1' WHEN s42, '1' WHEN s5, '1' WHEN s63, '1' WHEN s631, '1' WHEN s632, '1' WHEN s633, '1' WHEN s634, '0' WHEN OTHERS; WITH state SELECT mar_on_adbus <= '1' WHEN s2, '1' WHEN s4, '1' WHEN s42 , '1' WHEN s5, '1' WHEN s51, '1' WHEN s62, '1' WHEN s63, '1' WHEN s631, '1' WHEN s632, '1' WHEN s633, '1' WHEN s634, '1' WHEN s7, '0' WHEN OTHERS; WITH state SELECT dbus_on_databus <= '1' WHEN s62, '0' WHEN OTHERS; --Salidas de control ALU WITH state SELECT arith_shift_left <= '1' WHEN s322, '0' WHEN OTHERS; WITH state SELECT arith_shift_right <= '1' WHEN s323, '0' WHEN OTHERS; WITH state SELECT alu_and <= '1' WHEN s632, '0' WHEN OTHERS; WITH state SELECT alu_not <= '1' WHEN s321, '0' WHEN OTHERS; WITH state SELECT

51

alu_a

<= '1' WHEN s2, ' '1' WHEN s631,

1' WHEN s4, '1' WHEN s51, '0' WHEN OTHERS;

WITH state SELECT alu_add <= '1' WHEN s633, '0' WHEN OTHERS; WITH state SELECT alu_b <= '1' WHEN s32, '0' WHEN OTHERS; WITH state SELECT alu_sub <= '1' WHEN s634, '0' WHEN OTHERS; --Seales de control de memoria WITH state SELECT read_mem <= '1' WHEN s2, '1' WHEN s4, '1' WHEN s42, '1' WHEN s5, '1' WHEN s51, '1' WHEN s6, '1' WHEN s63, '1' WHEN s631, '1' WHEN s632, '1' WHEN s633, '1' WHEN s634, '0' WHEN OTHERS; WITH state SELECT write_mem <= '0' WHEN OTHERS; END dataflow;

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

52

ANEXO B. Max Plus II

Max Plus II es una herramienta para la sntesis de circuitos digitales perteneciente a la compaa ALTERA, es el programa adoptado por la Universidad Nacional de Colombia, Sede Manizales en el rea de anlisis y diseo de circuitos digitales. Ofrece la posibilidad de trabajar con dos lenguajes de descripcin de hardware HDLs : AHDL (Altera Hardware Description Languaje) desarrollado por la compaa fabricante y VHDL adoptado y estandarizado por la IEEE.
CONTENIDO

El hecho de ser un programa orientado hacia la sntesis

empleando diversas familias de dispositivos, y no hacia la simulacin hace que no sea compatible 100% con VHDL, ejemplo de esto es que no soporta retardos. Este anexo no pretende ser un manual de usuario (vase directorio tutoriales en CD adjunto) pero si determinar las pautas mnimas que marcaron la realizacin de este proyecto.
TABLAS
FIGURAS LISTADOS

Como primera medida se debe sealar que el nombre del archivo vhd a compilar debe ser el
ANEXOS

mismo de la entidad que describe. Tambin es importante conservar el orden jerrquico para que las entidades superiores puedan llamar a los archivos de extensin dls de las entidades bsicas. En ese orden de ideas se debe compilar inicialmente los paquetes basic_utilities.vhd, par_utilities, alu_operations y instruccin.vhd en el estricto orden en que se mencionaron; posteriormente los cinco registros ( accumulator_unit.vhd, instruction_register_unit.vhd, status_register_unit.vhd, memory_address_register_unit.vhd program_counter_unit.vhd ), las dos unidades combinacionales ( shifter_unit.vhd arithmetic_logic_unit.vhd ), la ESTRUCTURA DE BUSES (par_data_path.vhd), UNIDAD DE CONTROL ( par_control_unit.vhd ), y la

la UNIDAD CENTRAL DE

PROCESAMIENTO (par_central_procesing_unit.vhd) (vase Figura 2) y finalmente el programa que cumple las funciones de circuito prueba (parwan_tester.vhd). Todos estos archivos deben estar en un mismo directorio.

53

A continuacin se ilustran a groso modo los pasos que deben seguir con el Max Plus II, para compilar, simular y apreciar los diagramas de tiempo. Las diferentes acciones presentes en los mens se escriben en letra cursiva y negrilla.

Para compilar cada archivo desde el editor de texto se acciona Max+plus II / Compiler y aparecer el compilador (vase Figura 20), despus se debe seleccionar entre las libreras estndar de la IEEE: 1076 de 1987 y 1164 de 1993.

CONTENIDO

TABLAS
FIGURAS LISTADOS

Figura 20. Compilador Max Plus 2

ANEXOS

Para elegir VHDL93 se activa la opcin Interfaces / VHDL netlist Reader Settings.. se mostrara el cuadro de dialogo de la figura 21, donde elegimos VHDL 1993.

54

CONTENIDO

TABLAS
FIGURAS LISTADOS

. Figura 21. Cuadro de dialogo: VHDL Netlist Reader Settings

ANEXOS

Otro aspecto de gran importancia es la eleccin del dispositivo, ya que este debe poseer una cantidad de compuertas tal que soporte las exigencia del diseo; en este proyecto se trabajaron todas las entidades con la familia FLEX 10kA. Para seleccionar estos dispositivos, se hace uso de la opcin Assign / Device presente en todos los componentes del programa, esta accin desplegar el cuadro de dialogo que permite elegir entre diferentes dispositivos (vase Figura 22).

55

Figura 22. Cuadro de dilogo: Device

Despus de compilarse con Max+plus II / Waveform editor se carga el editor de onda y se

CONTENIDO

procede a cargar los puertos y seales a observar accionando Node / Enter node from SNF... En el cuadro de dialogo emergente (vase Figura 23) ejecutar el botn List aparecen en el recuadro izquierdo las diferentes seales, se selecciona las que se desean observar, se trasladan al recuadro derecho y se acciona Ok.

TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 23. Cuadro de dialogo: Enter Nodes from SNF

56

Tambin es importante determinar el tiempo final de simulacin y el tamao de la grilla para el periodo del reloj accionando desde el editor de onda File / End Time (vase Figura 24) y Options / Grid size (vase Figura 25 ) respectivamente para obtener sendos cuadros de dialogo.

Figura 24. Cuadro de dialogo: End Time

Figura 25. Cuadro de dialogo: Grid Size

CONTENIDO

La unica seal que debe alterarse es la del reloj, convirtindola en una seal peridica, esto se hace seleccionando con el mouse la seal en el editor de onda, activando Edit / Overwrite / Clock.. (vase Figura 26) y del cuadro de dialogo ejecutamos el botn Ok.

TABLAS
FIGURAS LISTADOS

ANEXOS

Figura 26. Cuadro de dialogo: Overwrite clock

Finalmente se procede a simular, con Max+plus II / Simulator se activa el simulador (la Figura 27), se acciona el botn Star y se abre nuevamente el editor de onda para observar en el archivo de extensin SNF el comportamiento del sistema.

57

Figura 27. Simulador de Max Plus II

CONTENIDO

TABLAS
FIGURAS LISTADOS

ANEXOS

58

RESUMEN

El sistema a estudiar en este proyecto es un procesador desarrollado con fines pedaggicos y utilizando tcnicas de mediana y pequea escala de integracin, este procesador tiene un total de 21 instrucciones de programacin. Se pretende ilustrar el uso de VHDL como un lenguaje de modelado y diseo de sistemas digitales.

El documento se divide en tres captulos: el captulo 1 plantea de forma muy general el diseo, contextualiza al lector de la importancia de los lenguajes de descripcin de
CONTENIDO

hardware (HDLs) en la evolucin del diseo digital moderno y contiene la descripcin comportamental del procesador. El segundo captulo plantea la forma de diseo

TABLAS
FIGURAS LISTADOS

descendente, donde se divide el sistema reiteradamente en unidades funcionales ms pequeas, partiendo de niveles de abstraccin ms profundos hasta llegar a los de transferencia de registro (RT) que permiten ser simulados con VHDL. Finalmente el

ANEXOS

captulo 3 ilustra mediante diagramas de tiempo los resultados obtenidos en la ejecucin de un programa compuesto por diez instrucciones representativas bajo la herramienta de simulacin MAX PLUS II..