Upload
guim-garcia
View
71
Download
6
Embed Size (px)
Citation preview
Carmelo Cuenca Hernández y Francisca Quintana Domínguez
FUNDAMENTOS DE COMPUTADORES
CURSO 2005/2006 1. PROYECTO DOCENTE 2. TRANSPARENCIAS DEL CURSO 3. GUIONES DE PRÁCTICAS 4. COLECCIÓN DE PROBLEMAS DE
EXÁMENES
13877 - FUNDAMENTOS DECOMPUTADORES
PROYECTO DOCENTE CURSO: 2005/06
ASIGNATURA: 13877 - FUNDAMENTOS DE COMPUTADORES
CENTRO: Escuela Universitaria Informática
TITULACIÓN: Ingeniero Técnico en Informática de Sistemas
DEPARTAMENTO: INFORMÁTICA Y SISTEMAS
ÁREA: Arquitectura Y Tecnología de Computadores
PLAN: 11 - Año 2000 ESPECIALIDAD:CURSO: Primer curso IMPARTIDA: Segundo cuatrimestre TIPO: Obligatoria
CRÉDITOS: 4,5 TEÓRICOS: 3 PRÁCTICOS: 1,5
Descriptores B.O.E.
Organización básica de los computadores: elementos básicos; esquemas de funcionamiento,desripción de una máquina básica, programación.
Temario
1 Arquitectura de un computador y jerarquía de niveles (3horas)2 Arquitectura del nivel lenguaje máquina (10 horas) 2.1 Características generales del lenguaje máquina (3 horas) 2.2 Tipos de operandos e instrucciones (2 horas) 2.3 Modos de direccionamiento y formato de las instrucciones (2 horas) 2.4 Subrutinas (3 horas)3 Diseño del procesador (15 horas) 3.1 Diseño y control cableado de un camino de datos monociclo (4 horas) 3.2 Diseño y control cableado de un camino de datos multiciclo ( 8 horas) 3.3 Diseño y control microprogramado de un camino de datos multiciclo (3 horas)4 Rendimiento ( 2 horas)
Conocimientos Previos a Valorar
Los alumnos deberían haber cursado y aprobado la signatura de Sistemas Digitales, dondeadquirirían los conocimientos acerca de los sistemas de numeración y representación de lainformación más usuales, el álgebra de Boole y su aplicación para simplificación de funcionesbooleanas, las técnicas de implementación de circuitos combinacionales simples, los fundamentosy componentes básicos de los sistemas secuenciales para desarrollar sistemas secuencialessíncronos.También son necesarios algunos conocimientos básicos de programación en algún lenguaje de altonivel para saber diseñar programas sencillos, y representar esos algoritmos en pseudocódigo,diagramas de flujo o algún método equivalente.
Objetivos Didácticos
Fundamentos de Computadores es la asignatura que presenta los componentes de un computador yla organización de estos componentes para proporcionar, de una manera eficiente, las funcionesnecesarias para poder ejecutar programas.
Página 1
Obtener una visión general de la jerarquía de niveles de un computador.Saber diferenciar entre los conceptos de estructura y arquitectura de un computador.Conocer y comprender las características más importante de la arquitectura y estructura de uncomputador.Conocer y comprender los elementos básicos de la arquitectura del repertorio de instrucciones.Dominar la programación en lenguaje ensamblador de algún procesador como, por ejemplo, elMIPS R2000.Conocer y comprender los elementos estructurales del procesador para la ejecución de lasinstrucciones.Conocer los principios básicos y métodos de diseño de unidades de control cableadas ymicroprogramadas.Evaluar las alternativas de diseño, así como el rendimiento de computadores.
Metodología de la Asignatura
La metodología docente a utilizar durante la impartición de la asignatura incluye los siguientesprocedimientos:•Clases magistrales.•Clases prácticas en el laboratorio.•Resolución de problemas.•Tutorías.
Evaluación
La nota final de la asignatura será el resultado de la ponderación entre la nota de teoría y la nota delas prácticas de laboratorio. Para aprobar la asignatura es preciso haber superado ambas partes conuna nota mayor o igual a 5 puntos. La nota de teoría tendrá un peso de un 70% sobre la nota finaly la nota de prácticas de laboratorio un 30%.
La nota de teoría y de prácticas de laboratorio se obtendrá a partir de los exámenes de convocatoriade la asignatura, uno para teoría y otro para práctica, en la fecha que el Centro fije para ello. Así para calcular la nota final se utilizará la siguiente fórmula:NF = 0.7 NT +0.3 NP (siempre que NT>=5 y NP>=5)donde NF es la nota final, NT es la nota de teoría y NP es la nota de prácticas de laboratorio.
Descripción de las Prácticas
Práctica nº 1DescripciónEl simulador PCspim.ObjetivosFamiliarización con la herramienta para las prácticas de la asignatura.Material de laboratorio recomendadoOrdenador personal. Windows.Simulador PcspimNº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 2DescripciónLos datos en memoriaObjetivosAdquirir soltura en cómo están ubicados los datos en memoriaMaterial de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador PcspimNº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 3DescripciónCarga y almacenamiento de los datos
Página 2
ObjetivosEstudio de la forma en que se cargan y almacenan los datos. Poner en práctica losconocimientos adquiridos en las clases teóricas sobre el repertorio de instrucciones MIPS.Material de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador PcspimNº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 4DescripciónLas operaciones aritméticas y lógicas.ObjetivosAdquirir soltura en el uso de las instrucciones aritméticas lógicas. Poner en práctica losconocimientos adquiridos en las clases teóricas sobre el repertorio de instrucciones MIPS.Material de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador Pcspim2Nº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 5DescripciónInterfaz con el programaObjetivosFamiliarización con la forma en que el PCSPIM permite realizar entrada y salida dedatos.Material de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador PcspimNº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 6DescripciónEstructuras de control:condicionales y buclesObjetivosAdquirir soltura en el uso de las instrucciones que permiten implementar estructurascondicionales y buclesMaterial de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador PcspimNº horas estimadas en Laboratorio2Nº horas total estimadas para la realización de la práctica2
Práctica nº 7DescripciónGestión de subrutinasObjetivosEstudio de la forma en que se manejan las subrutinas en lenguaje ensamblador.Material de laboratorio recomendadoOrdenador personal. Window NT 4.0.Simulador PcspimNº horas estimadas en Laboratorio3Nº horas total estimadas para la realización de la práctica3
Bibliografía
[1] Organización y diseño de computadores: la interfaz hardware/softwareHennessy, John L.
, McGraw-Hill, Madrid (1995) - (2ª ed.)
8448118294
[2] Computer organization and design: the hardware/software interfaceJohn L. Hennessy, David A. Patterson
Morgan Kaufmann, San Francisco (California) (1998) - (2nd ed.)
1-55860-491-X
[3] Introducción a la informáticaAlberto Prieto Espinosa, Antonio Lloris Ruiz, Juan Carlos Torres Cantero
McGraw Hill, Madrid (2001) - (3ª ed.)
8448132173
Página 3
[4] Organización de computadoras: un enfoque estructuradoAndrew S. Tanenbaum
Prentice Hall, México [etc.] (2000) - (4ª ed.)
970-17-0399-5
[5] Organización y arquitectura de computadores: diseño para optimizar prestacionesWilliam Stallings
Prentice Hall, Madrid (2000) - (5ª ed.)
84-205-2993-1
[6] Problemas y tests de introducción a la informática: con más de 400 problemas y 700 preguntas detests
por Beatriz Prieto Campos, Alberto Prieto Espinosa
Universidad de Granada, Departamento de Arquitectura y Tecnología de Computadores, Granada (2003)
8460791092
[7] Arquitectura de computadores: un enfoque cuantitativoJohn L. Hennessy, David A. Patterson
, McGraw-Hill, Madrid (1993)
8476159129
Equipo Docente
CARMELO CUENCA HERNANDEZ (COORDINADOR) Categoría: TITULAR DE ESCUELA UNIVERSITARIA
Departamento: INFORMÁTICA Y SISTEMAS
Teléfono: 928458713 Correo Electrónico: [email protected]
WEB Personal:
FRANCISCA QUINTANA DOMINGUEZ (RESPONSABLE DE PRACTICAS) Categoría: TITULAR DE ESCUELA UNIVERSITARIA
Departamento: INFORMÁTICA Y SISTEMAS
Teléfono: 928458736 Correo Electrónico: [email protected]
WEB Personal:
Página 4
Proyecto docente –Fundamentos de Computadores
http://serdis.dis.ulpgc.es/~itis-fcTitulación de Ingeniería Técnica en Informática de SistemasEscuela Universitaria de Informática
Curso 2005/2006 Fundamentos de Computadores 2
Proyecto Docente - Profesorado– Carmelo Cuenca Hernández (coordinador)
• [email protected]• Despacho 2-13 en el módulo 3• Horario de T U T O R Í A S
– Lunes de 11.00-13.00 y jueves 9.00-13.00– Francisca Quintana Domínguez (responsable de prácticas)
• [email protected]• Despacho 2-12 en el módulo 3• Horario de T U T O R Í A S
– Lunes de 9.30-12.30 y miércoles 9.30-12.30
Curso 2005/2006 Fundamentos de Computadores 3
Proyecto Docente – Horarios
B3-B4 L1.1
B1-B2 L1.1
A-5 L3.3
13:30-14:30
12:30-13:30
11:30-12:30
T AA3-A4 L1.1
A1-A2 L1.1
10:30-11:30
T B9:30-10:30
T BT A 8:30-9:30
VML
Curso 2005/2006 Fundamentos de Computadores 4
Proyecto docente - Objetivos de la asignatura
• Fundamentos de Computadores presenta los componentes de un computador y la organización de estos componentes para ejecutar programas– Obtener una visión general de la jerarquía de niveles de un computador– Conocer y comprender las características más importante de la
arquitectura y estructura de un computador– Conocer y comprender los elementos básicos de la arquitectura del
repertorio de instrucciones– Dominar la programación en lenguaje ensamblador de algún
procesador como, por ejemplo, el MIPS R2000– Conocer y comprender los elementos estructurales de un procesador
para la ejecución de las instrucciones– Conocer los principios básicos y métodos de diseño de unidades de
control cableadas y microprogramadas– Evaluar alternativas de diseño, así como el rendimiento de un
computador
Curso 2005/2006 Fundamentos de Computadores 5
Proyecto Docente - Temario1. Arquitectura de un computador y jerarquía de niveles (3
horas)2. Arquitectura del nivel lenguaje máquina (10 horas)
1. Características generales del lenguaje máquina2. Tipos de operandos e instrucciones3. Modos de direccionamiento y formato de las instrucciones4. Subrutinas
3. Diseño del procesador (15 horas)1. Diseño y control cableado de un camino de datos monociclo2. Diseño y control cableado de un camino de datos multiciclo3. Diseño y control microprogramado de un camino de datos
multiciclo 4. Rendimiento (2 horas)
Curso 2005/2006 Fundamentos de Computadores 6
Proyecto Docente - Prácticas
1.El simulador PCspim (2 horas)2.Los datos en memoria (2 horas)3.Carga y almacenamiento de los datos (2 horas)4.Las operaciones aritméticas y lógicas (2 horas)5. Interfaz con el programa (2 horas)6.Estructuras de control condicionales y bucles (2
horas)7.Gestión de subrutinas (3 horas)
Curso 2005/2006 Fundamentos de Computadores 7
Proyecto Docente - Evaluación
• Nota final = 0.7 Nota de teoría + 0.3 Nota de práctica(siempre que nota de teoría >=5 y Nota de
práctica>=5)• La nota de teoría y de práctica se
obtendrá en los exámenes de convocatoria de la asignatura, uno para teoría y otro para práctica
Arquitectura de un computador y jerarquía de niveles
“La arquitectura de un computador es la estructura de un computador que un
programador en lenguaje máquina debe conocer para escribir un programa correcto (independiente del tiempo)” Amdahl 1964
Curso 2005/2006 Fundamentos de Computadores 9
Objetivos• Establecer características para nominar una máquina como
computador• Conocer los hitos de la arquitectura de los computadores• Distinguir los diferentes niveles de estudio de los computadores• Entender los mecanismos de traducción e interpretación de niveles• Diferenciar entre la arquitectura y la estructura de un computador• Describir los componentes básicos de un computador y las
funcionalidades de cada uno de ellos por separados• Explicar el funcionamiento global de un computador a partir de las
relaciones de sus componentes básicos
Curso 2005/2006 Fundamentos de Computadores 10
Contenidos• Concepto de computador• Historia de los computadores
– La 1ª generación (los primeros computadores)– La 2ª generación (transistores)– La 3ª generación (SCI), la 4ª (LSI) y la 5ª (VLSI, UVLSI)
• Organización estructurada de un computador– Lenguajes, niveles y máquinas virtuales– Computador multinivel
• Funcionamiento de un computador– Componentes de un computador– Ciclo de instrucción– Interconexión con buses
• El futuro de los computadores– Ley de Moore
Curso 2005/2006 Fundamentos de Computadores 11
Concepto de computador• Diccionario de la Lengua Española
– “Máquina electrónica dotada de una memoria de gran capacidad y de métodos de tratamiento de la información, capaz de resolver problemas aritméticos y lógicos gracias a la utilización automática de programas registrados en ella”
• Microsoft Encarta – “Dispositivo electrónico capaz de recibir un conjunto de instrucciones y
ejecutarlas realizando cálculos sobre los datos numéricos, o bien compilando y correlacionando otros tipos de información”
• Enciclopedia Británica– “Device for processing, storing, and displaying information”
• Wikipedia– “Sistema digital con tecnología microelectrónica capaz de procesar
información a partir de un grupo de instrucciones denominado programa”
Historia de los computadores
"Quien olvida las lecciones de la historia
queda condenado a repetirla."Will Durant, Lecciones de la Historia
Curso 2005/2006 Fundamentos de Computadores 13
ENIAC – ¿Qué, quiénes, …?• Electronic Numerical Integrator
And Computer• Eckert y Mauchly• Universidad de Pennsylvania• Tablas de trayectorias
balísticas• Año de inicio 1943• Año de finalización 1946
– Tarde para la Segunda Guerra Mundial (1939-1945)
• En funcionamiento hasta 1955
Curso 2005/2006 Fundamentos de Computadores 14
ENIAC - detalles• Decimal (no binario)• 20 registros acumuladores de
10 dígitos• Programado manualmente
mediante 6000 interruptores• 18000 tubos de vacío y 1500
relevadores• 30 toneladas• 15000 pies cuadrados• 140 Kw de consumo de
potencia• 5000 sumas por segundo
Curso 2005/2006 Fundamentos de Computadores 15
Von Neumann/Turing• Concepto de programa
almacenado• Componentes de un computador
– La memoria principal (MM) almacena programas y datos
– La unidad aritmética lógica (ALU) opera con datos binarios
– La unidad de control (UC) interpreta y provoca la ejecución de las instrucciones en memoria
• Máquinas– EDSAC – la primera computadora
de programa almacenado• Maurice Wilkes, Universidad de
Cambridge, (¿?-1949)– La máquina IAS
• John von Neumann y Herman Goldstine, Instituto para Estudios Avanzados de Princeton, (1946-1952)
Curso 2005/2006 Fundamentos de Computadores 16
Estructura de una máquina vonNeumann
• Cinco partes básicas:– la memoria (M), almacena datos e instrucciones– la unidad aritmética lógica (ALU), capaz de hacer operaciones
con datos binarios– la unidad de control (UC), interpreta y provoca la ejecución de
las instrucciones en memoria– el equipo de entrada y salida (I/O)
Curso 2005/2006 Fundamentos de Computadores 17
IAS - detalles• Aritmética binaria• 1000 palabras de 40 bits• 2 registros de instrucciones de
20 bits• Registros dentro de la CPU
– R. temporal de memoria (MBR)
– R. de direcciones de memoria (MAR)
– R. de instrucciones (IR)– R. temporal de instrucciones
(IBR)– R. contador de programa (PC)– R. acumulador (AC)– R. multiplicador cociente (MQ)
Curso 2005/2006 Fundamentos de Computadores 18
Computadores comerciales• 1947 – Eckert-Mauchly Computer Comportation
– UNIVAC I (Universal Automatic Computer)• Aplicaciones científicas y comerciales• Oficina del censo en 1950• Operaciones algebraicas con matrices, problemas de
matrices, primas para las compañías de seguro, problemas logísticos ...
– Absorción por Sperry-Rand Comporation– UNIVAC II a finales de los 50
• Más rápido• Más memoria
– Serie UNIVAC 1100
Curso 2005/2006 Fundamentos de Computadores 19
IBM• Fabricante de equipos de
procesamiento con tarjetas perforadas
• 1953 – El 701 para aplicaciones científicas
• 1955 – El 702 para aplicaciones de gestión
• Líder mundial con las series 700/7000
Curso 2005/2006 Fundamentos de Computadores 20
La segunda generación: los transistores (1955-1965)
• Invención de Shockley y otros de los laboratorios Bell en 1947
• Sustitución de los tubos de vacío por transistores
• Ventajas del transistor– Más pequeño– Más barato– Menor disipación de calor– Fabricado con silicio
(arena)
Curso 2005/2006 Fundamentos de Computadores 21
Computadores con transistores• NCR y RCA fueron los
primeros en comercializar pequeñas máquinas con transistores
• IBM 7000• 1957 - Fundación de
Digital EquipmentCorporation (DEC) pionera de los minicomputadores– PDP 1
Curso 2005/2006 Fundamentos de Computadores 22
La 3ª, 4ª y 5ª generación: los circuitos integrados (1965-????)
• Un computador consta de puertas, celdas de memoria e interconexiones
• Tales componentes podían ser fabricados a partir de un semiconductor como el silicio en un circuito integrado (RobertNoyce – 1958)
• Generaciones 3ª, 4ª y 5ª de computadores– 3ª generación
• Pequeña y mediana integración (SCI) 1965-1971• Hasta 100 componentes en un chip• 1965 - IBM líder mundial inicia la “familia” 360• 1965 - DEC lanza el minicomputador de bajo coste PDP-8
– 4ª generación• Gran integración (LSI ) 1972-1977• Entre 3000 y 100000 componentes en un chip
– 5ª generación• Alta Integración (VLSCI y UVLSI) 1978-????• Más de 100000000 componentes en un chip
Organización estructurada de un computador
Los computadores están diseñados como una serie de niveles, cada uno construido
sobre sus predecesores. Cada nivel representa una abstracción distinta, y
contiene diferentes objetos y operaciones
Curso 2005/2006 Fundamentos de Computadores 24
Lenguajes, niveles y máquinas virtuales
• La máquina virtual Mi ejecuta sólo programas escritos en el lenguaje de programación Li
• Ejecución de programas en Mi:– Traducción
• Un programa “traductor” sustituye cada instrucción escrita en Li por una secuencia equivalente de instrucciones en Li-1. El programa resultante consiste exclusivamente en instrucciones de Li-1. Luego, Mi-1 ejecuta el programa en Li-1
– Interpretación• Un programa “intérprete” escrito
en Li-1 examina las instrucciones una por una y ejecuta cada vez la sucesión de instrucciones en Li-1que equivale a cada una
Curso 2005/2006 Fundamentos de Computadores 25
Computador multinivel• N. aplicaciones
– Microsoft Office, eMule…• N. lenguaje alto nivel
– BASIC, C, C++, Java, Lisp, Prolog• N. lenguaje ensamblador• N. sistema operativo
– Archivo, partición, proceso, …• N. arquitectura del repertorio de
instrucciones (ISA)– Salto, pila, …
• N. microarquitectura– Banco de registros, ALU, camino de
datos• N. lógica digital
– Puertas lógicas: AND, OR …, biestables, registros …
• N. dispositivos– Transistores, diodos, estado sólido …
Funcionamiento de un computador
Curso 2005/2006 Fundamentos de Computadores 27
Componentes de un computador
• Unidad central de proceso (CPU)– Unidad de control
(UC)– Unidad aritmética-
lógica (ALU)• Memoria (M)• Entrada y salida (E/S)
Curso 2005/2006 Fundamentos de Computadores 28
Ciclo de instrucción (1/2)• Ciclo de búsqueda de instrucción
– El registro contador de programa (PC) contiene la dirección de la siguiente instrucción a ejecutar
– El procesador busca la instrucción a partir de la localización de memoria señalada por el PC
– El procesador incrementa el contador de programa (hay excepciones)– La instrucción es cargada en el registro de instrucciones (IR)
Curso 2005/2006 Fundamentos de Computadores 29
Ciclo de instrucción (2/2)• Ciclo de ejecución (5 tipos)
– Procesador-memoria: transferencia de datos desde la CPU a la memoria o al revés
– Procesador-E/S: transferencia de datos a o desde el exterior– Procesamiento de datos: la CPU ha de realizar alguna operación aritmética o
lógica con los datos– Control: una instrucción puede especificar que la secuencia de ejecución sea
alterada– Combinaciones de las anteriores
Curso 2005/2006 Fundamentos de Computadores 30
Ejemplo de ejecución de programa
Curso 2005/2006 Fundamentos de Computadores 31
Diagrama de estados del ciclo de instrucción
Curso 2005/2006 Fundamentos de Computadores 32
Esquema de interconexión mediante buses
• Conjunto de conductores eléctricos para la conexión de dos o más dispositivos
• Tipos de buses– De memoria, de datos y de
control– Anchura de los buses: 8, 16,
32, 64 bits• ¿Cómo son los buses?
– Pistas paralelas de los circuitos impresos
– Cintas de plástico con hilos conductores
– Conectores (ISA, PCI, …)– Cables sueltos
Curso 2005/2006 Fundamentos de Computadores 33
Bus ISA(Industry Standard Architecture)
Curso 2005/2006 Fundamentos de Computadores 34
Bus de alta prestaciones
El futuro de los computadores
La relación coste/rendimiento ha mejorado los últimos 45 años
aproximadamente 240 000 000 (un 54% anual)
Curso 2005/2006 Fundamentos de Computadores 36
Ley de Moore
• La densidad de integración dobla cada 18 meses
• ¿Válida hasta 2020?)
Arquitectura del repertorio de instrucciones (ISA)
“La arquitectura de un computador es la estructura del computador que un programador en lenguaje máquina
debe conocer para escribir un programa correcto (independiente del tiempo)”
Amdahl 1964
Curso 2005/2006 Fundamentos de Computadores 2
Objetivos• Caracterizar una instrucción de acuerdo con el tipo de operación, de datos, de modos de
direccionamiento y de formato de codificación• Codificar una instrucción de lenguaje máquina a una instrucción de lenguaje ensamblador y
viceversa• Distinguir una pseudoinstrucción de una instrucción• Explicar con comentarios la finalidad de un bloque básico de código ensamblador• Determinar los valores intermedios y finales de los registros y los contenidos de la memoria tras
la ejecución de un bloque básico de código ensamblador• Escribir la secuencia de instrucciones de lenguaje ensamblador correspondiente a una
pseudoinstrucción • Traducir las sentencias básicas de asignación, operación, toma de decisiones, bucles y llamadas
a procedimientos a lenguaje ensamblador• Traducir un algoritmo escrito en un lenguaje de alto nivel a lenguaje ensamblador y viceversa• Escribir procedimientos en lenguaje ensamblador consecuentes con los convenios de pasos de
parámetros a procedimientos• Corregir errores en un programa escrito en lenguaje ensamblador para que funcione
correctamente• Calcular el tiempo de ejecución y los ciclos por instrucción (CPI) de un bloque básico de código
ensamblador• Diseñar un repertorio de instrucciones con restricciones de diseño
Curso 2005/2006 Fundamentos de Computadores 3
Índice• Estructura de una máquina Von Neumman• Máquinas RISC• MIPS R3000 – Nivel ISA
– Instrucciones aritmético-lógicas– Instrucciones de acceso a memoria
• Organización de la memoria• Carga y almacenamiento
– Instrucciones de salto condicional– Lenguaje máquina
• Instrucciones aritmético-lógicas, de acceso a memoria, de carga y almacenamiento, de salto condicional e incondicional– Datos inmediatos– Gestión de procedimientos
• Llamadas y retornos de procedimientos• Convenio de uso de registros• Gestión de la pila
– Otras instrucciones• Máquinas CSIC• IA – 32
– Características del ISA– Registros– Instrucciones básicas– Formato de las instrucciones
Curso 2005/2006 Fundamentos de Computadores 4
Estructura de una máquina von Neumann
• Cinco partes básicas– la memoria (M)– la unidad aritmética
lógica (ALU– la unidad de control
(UC)– el equipo de entrada y
salida (I/O)• Ciclo de instrucción
– Ciclo de búsqueda– Ciclo de ejecución
Curso 2005/2006 Fundamentos de Computadores 5
1400
1300
1200
1100
1000
900
800
700
600
500
400
300
200
100
01998 2000 2001 20021999
OtherSPARCHitachi SHPowerPCMotorola 68KMIPSIA-32ARM
RISC - Reduced Instruction Set Computer
• RISC es una filosofía de diseño con las siguientes características:– Tamaño fijo de las instrucciones– Número reducido de codificaciones de las instrucciones, modos de
direccionamientos y operaciones– Instrucciones de load/store para los accesos a memoria, registros
• Usados por NEC, Nintendo, Silicon Graphics, Cisco, Sony...
Curso 2005/2006 Fundamentos de Computadores 6
MIPS R3000 – Nivel ISA
• Instrucciones de 32 bits• 3 formatos• 4 direccionamientos• 5 tipos de instrucciones
– Aritmético-lógicas– Acceso a memoria– Ruptura de secuencia– Gestión de memoria– Especiales
• 32 registros de 32 bits de propósito general (GPR)
$0 - $31
PCHILO
Registros
OP
OP
OP
rs rt rd sa funct
rs rt immediate
jump target
3 Instruction Formats: all 32 bits wide
R format
I format
J format
OP
OP
OP
rs rt rd sa funct
rs rt immediate
jump target
3 Instruction Formats: all 32 bits wide
R format
I format
J format
Curso 2005/2006 Fundamentos de Computadores 7
MIPS – Instrucciones aritmético-lógicas
• Principio de diseño 1– “La simplicidad favorece la uniformidad”
• Todos los computadores deben ser capaces de realizar cálculos aritméticos y lógicos
add a, b, c # a b + csub a, a, d # a a + d = (b + c) - dor a, a, e # a a + e = (b + c + d) OR e
Curso 2005/2006 Fundamentos de Computadores 8
Ejemplos básicos de compilación de sentencias
• Dos sentencias de asignación de C en MIPS– Código fuente
a = b + c;d = a – e;
– Compilaciónadd a, b, csub d, a, e
• Compilación de una sentencia compleja de C en MIPS– Código fuente
f = (g + h) – (i + j);– Compilación
add t0, g, hadd t1, i, jsub f, t0, t1
Curso 2005/2006 Fundamentos de Computadores 9
MIPS - Registros
• Principio de diseño 2– “Cuanto más pequeño más rápido”
• Los operandos de las instrucciones computacionales son registros• Los compiladores asocian variables con registros
– $s0, $s1,... para registros asociados a variables de C– $t0, $t1,... para registros temporales– Otros más
$0 - $31
PCHILO
Registers
Processor I/O
Control
Datapath
Memory
Input
Output
Processor I/O
Control
Datapath
Memory
Input
Output
Curso 2005/2006 Fundamentos de Computadores 10
Ejemplo de compilación de una asignación usando registros
• Código fuente de Cf = (g + h) – (i+j);
f, g, h, i y j en $s0, $s1, $s2, $s3 y $s4• Compilación en MIPS
add $t0, $s1, $s2 # el registro $t0 contiene# g+h
add $t1, $s3, $s4 # el registro $t1 contiene# i +j
sub $s0, $t0, $t1 # f contiene $t0 - $t1, que# es (g+h) – (i+h)
Curso 2005/2006 Fundamentos de Computadores 11
Accesos a memoria - Organización de la memoria
• La memoria es un vector de bytes
• La dirección es un índice dentro del vector de bytes
• 2 posibles ordenaciones para las palabras:– Big Endian (IA-32)– Little Endian (MIPS)
• Alineación de datos– address módulo size = 0
Objeto Bien alineado Mal alineado
Byte 0,1,2,3,4,5,6,.. (nunca)
Media palabra 0,2,4,6,8, ... 1,3,5,7, ...
Palabra (4 bytes) 0,4,8,... 1,2,3,5,6,7,9,10,11,...
Doble palabra 0,8, .. 1,2,3,4,5,6,7,9,10,11,12,13,14,15,....
.0x110x220x330x44
.55
.0x110x220x330x44
.55
Big EndianLittle EndianMSB LSB0x44332211
Memoria…0x110x220x330x44
…55
Big EndianLittle EndianMSB LSB0x44332211
MemoriaBig EndianLittle Endian
MSB LSB0x44332211
Memoria MSB LSB0x11223344
Curso 2005/2006 Fundamentos de Computadores 12
Accesos a memoria – Organización de la memoria del MIPS
• El tamaño de las palabras es de 32 bits• Big Endian• 232 posiciones de memoria de bytes, 0, 1, 232-1• Accesos alineados
– 231 posiciones de memoria de medias palabras, 0, 2… 232-2
– 230 posiciones de memoria de palabras, 0, 4, 232-4– 228 posiciones de memoria de dobles palabras, 0, 8…
232-8
Curso 2005/2006 Fundamentos de Computadores 13
MIPS – Cargas y almacenamientos
• Instrucciones para accesos a memoria de palabras– lw $t0, 4($s3) # $t0 M[$s3+4]– sw $t0, 4($s3) # M[$s3+4] $t0
• La suma del registro base ($s3) y el desplazamiento (4) forma la dirección de memoria del dato– El desplazamiento tiene signo (complemento a dos)– Los accesos están limitados a una región centrada en
el registro base de ±213 palabras
Curso 2005/2006 Fundamentos de Computadores 14
Ejemplo de compilación con un dato en memoria
• Código fuente de Cg = h + A[8];
La base del vector asignada a $s3, las variables g y h asignadas a $s1 y $s2
• Compilación en MIPSlw $t0, 32($s3) # $t0 contiene A[8]add $s1, $s2, $t0# $s1 contiene g = h + A[8]
Curso 2005/2006 Fundamentos de Computadores 15
Ejemplo de compilación de una asignación con un índice variable
• Código fuente de Cg = h + A[i];
la base del vector en $s3, g y h e i en $s1, $s2 y $s4
• Compilación en MIPSadd $t1, $s4, $s4 # $t1 contiene 2 * iadd $t1, $t1, $t1 # $t1 contiene 4 * iadd $t1, $t1, $s3 # $t1 contiene $s3 + 4 * ilw $t0, 0($t1) # $t0 contiene A[i]add $s1, $s2, $t0 # $s1 contiene g = h + A[i]
Curso 2005/2006 Fundamentos de Computadores 16
MIPS – Instrucciones de salto condicional
• Instrucciones de salto condicional (sólo dos)– bne $s0, $s1, L1 # branch to L1 if no equal– beq $s0, $s1, L1 # branch to L1 if equal
• Pseudoinstrucciones de salto condicional– slt (set si menor que), beq, bne y $zero permiten las
condiciones restantesblt $s1, $s2, etiqueta # salta si menor queslt $at, $s1, $s2bne $at, $zero, etiqueta
– El ensamblador expande las pseudoinstrucciones• $at, registro utilizado por el programa ensamblador
Curso 2005/2006 Fundamentos de Computadores 17
Ejemplo de compilación de una sentencia de salto condicional
• Código fuente de CIf (i==j) h = i + j;
h, i y j en $s0, $s1 y $s2• Compilación en MIPS
bne $s1, $s2, etiquetaadd $s0, $s1, $s2
etiqueta: …
Curso 2005/2006 Fundamentos de Computadores 18
Lenguaje máquina – Instrucciones aritmético-lógicas
• El tamaño de las instrucciones es de 32 bits• Las instrucciones aritmético-lógicas son codificadas con el formato tipo-R
– add $rd, $rs, $rt• Significado de los campos
– op 6-bits código de operación– rs, rt, rd 5-bits registro source, target, destination– shamt 5-bits número de bits a desplazar (cuando aplicable)– funct 6-bits código de función (extensión del código de operación)
op rs rt rd shamt funct Formato de instrucciones aritméticas6 bits 5 bits 5 bits 5 bits 5 bits 6 bits Todas las instrucciones MIPS de 32 bits000000 01010 11111 00011 00000 100000 0x015f1820 add $3,$10,$31
Curso 2005/2006 Fundamentos de Computadores 19
Lenguaje máquina – Instrucciones de acceso a memoria
• Principio de diseño 3– “Un buen diseño necesita buenas soluciones de compromiso”
• Las instrucciones de load y store especifican dos registros y undesplazamiento
– Formato tipo I (16 bits para el dato inmediato)– lw $rt, inmediato($rs), sw $rt, inmediato($rs– lh, lhu, lb, lbu sh, sb (load half, half unsigned, byte, byte unsigned; store half,
byte)
op rs rt Dirección/inmediato Formato de instruciones de carga6 bits 5 bits 5 bits 16 bits Todas las instrucciones MIPS de 32 bits100011 00011 00101 0000000000100000 0x8c650020 lw $5,32($3)
Curso 2005/2006 Fundamentos de Computadores 20
Traducción de lenguaje ensamblador a lenguaje máquina
• Código fuente de CA[300] = h + A[300];
La base del vector asignada a $t1 y h a $s2• Compilación en MIPS
lw $t0, 1200($t1)add $t0, $s2, $t0sw $t0, 1200($t1)
• Lenguaje máquina1000 1101 0010 1000 0000 0100 1011 00000000 0010 0100 1000 0100 0000 0010 00001010 1101 0010 1000 0000 0100 1011 0000
Curso 2005/2006 Fundamentos de Computadores 21
Lenguaje máquina – Instrucciones de salto condicional
• Formato tipo I (16 bits para el dato inmediato)– El inmediato codifica el nº de palabras desde la siguiente
instrucción a la instrucción de salto (PC+4) hasta la instrucción destino
– Los saltos están limitados a una región centrada en el PC + 4 de ±215 palabras
PCAdd
32
32 3232
32
offset16
32
00
sign-extend
from the low order 16 bits of the branch instruction
branch dstaddress
?Add
4 32
PCAdd
32
32 3232
32
offset16
32
00
sign-extend
from the low order 16 bits of the branch instruction
branch dstaddress
??Add
4 32
Curso 2005/2006 Fundamentos de Computadores 22
MIPS – Instrucciones de ruptura de secuencia incondicional
• j etiqueta• Formato tipo J
– 6 bits código de operación + 26 bits para el dato inmediato– El inmediato de 26 bits codifica la dirección absoluta de la
palabra con la instrucción destino de salto dentro de un segmento de 256MB
op 26-bit addressop 26-bit address
PC4
32
26
32
00
from the low order 26 bits of the jump instruction
PC4
32
26
32
00
from the low order 26 bits of the jump instruction
Curso 2005/2006 Fundamentos de Computadores 23
Ejemplo de compilación de una sentencia de salto if-then-else
• Código fuente de CIf (i==j) f = g + h;else f = g – h;
i, j, f, g y h en $s0… $s4• Compilación en MIPS
bne $s0, $s1, L1add $s2, $s3, $s4 # f = g + hj L2 # salto incondicional
L1: sub $s2, $s3, $s4 # f = g - hL2: …
Curso 2005/2006 Fundamentos de Computadores 24
MIPS – Datos inmediatos (1/2)• Instrucciones aritmético-lógicas con un operando
constanteslti $t0, $s2, 15 #$t0 = 1 si $s2<15
• La constante almacenada en la propia instrucción– Formato tipo I– El dato inmediato está limitado a 16 bits (-215 a +215-1)
op rs rt 16 bit immediate I formatop rs rt 16 bit immediate I format
Curso 2005/2006 Fundamentos de Computadores 25
MIPS – Datos Inmediatos (2/2)
• Gestión de datos inmediatos de más de 16 bits– Almacenaje en memoria
.datamuchosbits:
.word 4294967295 # 0x7FFFFFFF.text
…lw $t0, muchosbits($zero)
– Descomposición en parteslui $at, 0x7FFFF # load upper inmediateori $t0, $at, 0xFFFF
Curso 2005/2006 Fundamentos de Computadores 26
MIPS – Gestión de procedimientos
• Llamada a procedimiento– jal address
• Escribe PC+4 en el registro $ra (return adress, $31) para posibilitar el retorno del procedimiento
• Instrucción tipo J– jalr $rs
• Instrucción tipo R
• Retorno de procedimiento– jr $ra
• Instrucción tipo R
Curso 2005/2006 Fundamentos de Computadores 27
MIPS – Convenio de uso de registros
Name Register number Usage$zero 0 the constant value 0$v0-$v1 2-3 values for results and expression evaluation$a0-$a3 4-7 arguments$t0-$t7 8-15 temporaries$s0-$s7 16-23 saved$t8-$t9 24-25 more temporaries$gp 28 global pointer$sp 29 stack pointer$fp 30 frame pointer$ra 31 return address
Curso 2005/2006 Fundamentos de Computadores 28
MIPS – Pila (stack)
• Operaciones– Guardar (Push)
addi $sp, $sp, -4sw $rs, 0(Sp)
– Recuperar (Pop)lw $rs, 0(Sp)addi $sp, $sp, 4
Memoria Dirección
Baja
Valor guardado
Alta
sp-4
sp
Memoria Dirección
Baja
Valor leído
Alta
sp+4
sp
Curso 2005/2006 Fundamentos de Computadores 29
MIPS - Instrucciones aritméticasInstrucción Ejemplo Significado Comentarios
sumar add $1,$2,$3 $1= $2+$3 Posible excepción por desbordamiento sumar sin signo addu $1,$2,$3 $1=$2+$3 - sumar inmediato addi $1,$2,10 $1=$2+10 Posible excepción por desbordamiento sumar inmediato sin signo addiu $1,$2,10 $1=$2+10 - restar sub $1,$2,$3 $1=$2-$3 Posible excepción por desbordamiento restar sin signo subu $1,$2,$3 $1=$2-$3 -
dividir div $1,$2 Lo=$1÷$2 Hi=$1mod$2
Posible excepción por desbordamiento
dividir sin signo divu $1,$2 Lo=$1÷$2 Hi=$1mod$2 -
multiplicar mult $1,$2 Hi,Lo=$1*$2 - multiplicar sin signo multu $1,$2 Hi,Lo=$1*$2 -
Pseudoinstrucciones
dividir div $1,$2,$3 $1=$2÷$3 (cociente)
Posible excepción por desbordamiento
dividir sin signo divu $1,$2,$3 $1=$2÷$3 (cociente) -
multiplicar mul $1,$2,$3 $1=$2*$3 - multiplicar mulo $1,$2,$3 $1=$2*$3 Posible excepción por desbordamiento multiplicar sin signo mulou $1,$2,$3 $1=$2*$3 Posible excepción por desbordamiento
Curso 2005/2006 Fundamentos de Computadores 30
MIPS – Intrucciones lógicas
Instrucción Ejemplo Significado Comentarios and and $1,$2,$3 $1= $2&$3 or andi $1,$2,10 $1=$2&10 xor xor $1,$2,$3 $1=$2⊕$3 nor nor $1,$2,$3 $1=~($2|$3) andi andi $1,$2,10 $1=$2&10 ori ori $1,$2,10 $1= $2|10 xori xori $1,$2,10 $1=$2|10 shift left logical sll $1,$2,10 $1= $2<<10 shift left logical variable sllv $1,$2,$3 $1= $2<<$3 shift right logical srl $1,$2, 10 $1=$2>>10 shift right logical variable srlv $1,$2,$3 $1=$2>>$3 shift right arithmetic sra $1,$2,10 $1=$2>>10 shift right arithmetic variable srav $1,$2,$3 $1=$2>>$3
Curso 2005/2006 Fundamentos de Computadores 31
MIPS - Instrucciones de transferencia de datos (1/2)
Instrucción Ejemplo Significado Comentarios carga byte lb $1,10($2) $1=M[10+$2] Extiende el bit de signo carga byte sin ext. signo lbu $1,10($2) $1=M[10+$2] No extiende el bit de signo carga media palabra lh $1,10($2) $1=M[10+$2] Extiende el bit de signo carga media palabra sin extensión de signo lhu $1,10($2) $1=M[10+$2] No extiende el bit de signo
carga palabra lw $1,10($2) $1=M[10+$2] carga inmediata de la parte más significativa “load upper inmediate”
lui $1,50 $1=50*216 Carga un dato de 16 bits en la parte más significativa del registro.
Carga registro del coprocesador z lwc1 $f0,10($2) $f0= M[10+$2]
almacena byte sb $1,10($2) M[10+$2]=$1 almacena media palabra sh $1,10($2) M[10+$2]=$1 almacena palabra sw $1,10($2) M[10+$2]=$1 almacena registro en memoria registro del coprocesador z
swc1 $f0,10($2) M[10+$2]=$f0
Pseudoinstrucciones Carga inmediata li $1,1000 $1=1000 Carga de un dato de 32 bits
Carga dirección la $3,label $3=dirección de label
Transfiere la dirección de memoria no el contenido.
Curso 2005/2006 Fundamentos de Computadores 32
MIPS – Instrucciones de movimiento de datos (2/2)
Instrucción Ejemplo Significado Comentarios mover desde Hi mfhi $1 $1= Hi mover desde Lo mflo $1 $1= Lo mover a Hi mthi $1 Hi=$1 mover a Lo mtlo $1 Lo=$1 mover desde coprocesador z mfcz $1,$f0 $1=$f0 $f0-$f30: Registros del coprocesador 1 mover al coprocesador z mtcz $1,$f0 $f0=$1
Pseudoinstrucciones transfiere o mueve move $1,$2 $1=$2
transfiere doble desde coproc. 1 mfc1.d $4,$f0 $4=$F0 $5=$F1
Curso 2005/2006 Fundamentos de Computadores 33
Instrucciones de comparaciónInstrucción Ejemplo Significado Comentarios
Inicializar menor que slt $1,$2,$3
if ($2<$3) then $1=1 else $1=0 endif
inicializar menor que sin signo sltu $1,$2,$3 Inicializar menor que inmediato slti $1,$2,5 Inicializar menor que inmediato sin signo sltiu $1,$3,$5
Pseudoinstrucciones
Inicializa igual seq $1,$2,$3
si ($2==$3) then $1=1 else $1=0 endif
inicializa mayor o igual sge $1,$2,$3 inicializa mayor que sgt $1,$2,$3 inicializa menor o igual sle $1,$2,$3 inicializa no igual sne $1,$2,$3
Curso 2005/2006 Fundamentos de Computadores 34
MIPS – Instrucciones de salto y bifurcación
Instrucción Ejemplo Significado Comentariossalta sobre igual beq $1,$2,100 si($1==$2 )ir a PC+4 +100 salta sobre no igual bne $1,$2,100 si($1!=$2) ir a PC+4 +100 salta sobre mayor o igual que cero bgez $1,100 si($1>=0) ir a PC+4 +100 salta sobre mayor o igual que cero y enlaza bgezal $1,1000 si($1>=0) $31=PC+4; ir a 1000
..... bifurcar j 2000 ir a 2000 bifurcar registro jr $1 ir a $1 Bifurcar y enlazar jal 10000 $31=PC+4; ir a 10000 bifurcar y enlazar registro jalr $1 $31=PC+4; ir a $1
Pseudoinstrucciones salta sobre mayor o igual bge $1,$2,100 si($1>=$2) ir a PC+4 +100 salta sobre mayor que bgt $1,$2,100 si($1>$2) ir a PC+4 +100 salta sobre menor o igual ble $1,$2,100 si($1<=$2) ir a PC+4 +100 salta sobre menor que blt $1,$2,100 si($1<$2) ir a PC+4 +100 .....
Curso 2005/2006 Fundamentos de Computadores 35
MIPS - Modos de direccionamientos
Byte Halfword Word
Registers
Memory
Memory
Word
Memory
Word
Register
Register
1. Immediate addressing
2. Register addressing
3. Base addressing
4. PC-relative addressing
5. Pseudodirect addressing
op rs rt
op rs rt
op rs rt
op
op
rs rt
Address
Address
Address
rd . . . funct
Immediate
PC
PC
+
+
Curso 2005/2006 Fundamentos de Computadores 36
CISC - Complex Instruction SetComputer
• CISC es una filosofía de diseño con las siguientes características:– Instrucciones con mayor contenido semántico
para conseguir una reducción del número de instrucciones ejecutadas
– Mayor tiempo de ciclo (Tc) o mayor número de ciclo por instrucción (CPI) que una arquitectura RISC
Curso 2005/2006 Fundamentos de Computadores 37
IA - 32• 1978 µP 8086/88 (16 bits, 40 pines)• 1980 coprocesador Intel 8087• 1982 µP 80286
– Direcciones de 24 bits– Niveles de privilegio
• 1986 µP 80386– Direcciones de 32 bits
• 1989 µP 80486– Coprocesador integrado– Caché L1 de 8KB
• 1993 Pentium– Bus interno 128 – 256 bits
• 1995-1999 Familia P6– Superscalares– MMX (57 instrucciones “MMX”)
• 1999 – 2005 Familia Pentium IV (478 pines)
– Hyper Threading– 70 instrucciones Streaming SIMD
Extensions
Curso 2005/2006 Fundamentos de Computadores 38
IA - 32
• Características del ISA– Longitud de instrucciones 1..17 bytes– Máquina de 2 operandos
• SUB AX, AX– Máquina registro-memoria
• ADD AX, [BX]– Modos de direccionamientos complejos
Curso 2005/2006 Fundamentos de Computadores 39
IA–32 Registros• 8 registros de 32 bits de
“casi propósito general”– GPR0-GPR7: EAX, ECX,
EDX, EBX, ESP, EBP, ESI, EDI
• 6 registros de segmento de 16 bits– CS, SS, DS, ES, FS, GS
• Un registro puntero de instrucción de 32 bits– EIP
• Un registro de estado de 32 bits– EFLAGS
GPR 0
GPR 1
GPR 2
GPR 3
GPR 4
GPR 5
GPR 6
GPR 7
Code segment pointer
Stack segment pointer (top of stack)
Data segment pointer 0
Data segment pointer 1
Data segment pointer 2
Data segment pointer 3
Instruction pointer (PC)
Condition codes
Use031
Name
EAX
ECX
EDX
EBX
ESP
EBP
ESI
EDI
CS
SS
DS
ES
FS
GS
EIP
EFLAGS
Curso 2005/2006 Fundamentos de Computadores 40
IA-32 Restricciones de uso de los registros de propósito general
Curso 2005/2006 Fundamentos de Computadores 41
IA-32 Instrucciones básicas• Movimiento de datos
– MOV, PUSH, POP• Aritmético-lógicas
– El destino registro o memoria– Aritmética entera y decimal– CMP activa los bits del registro CFLAGS
• Control de flujo– Saltos condicionales, incondicionales, llamadas y
retornos de procedimientos• Manipulación de cadena
– Movimiento y comparación de cadenas
Curso 2005/2006 Fundamentos de Computadores 42
IA-32 Formato de las instruccionesa. JE EIP + displacement
b. CALL
c. MOV EBX, [EDI + 45]
d. PUSH ESI
e. ADD EAX, #6765
f. TEST EDX, #42
ImmediatePostbyteTEST
ADD
PUSH
MOV
CALL
JE
w
w ImmediateReg
Reg
wd Displacementr/mPostbyte
Offset
DisplacementCondi-tion
4 4 8
8 32
6 81 1 8
5 3
4 323 1
7 321 8
Curso 2005/2006 Fundamentos de Computadores 43
Resumen• El nivel ISA es el interfaz hardware/software de un computador• Principios de diseño
– “La simplicidad favorece la uniformidad”• Tamaño de instrucciones fijo• No muchos formatos de instrucciones• Fácil codificación de las instrucciones
– “Cuanto más pequeño más rápido”• Número de instrucciones y modo de direccionamientos bajo• Número registros no excesivo
– “Un buen diseño necesita buenas soluciones de compromiso”• Equilibrio número de registros, número de instrucciones, tipos y tamaño de
las instrucciones– “Hacer el caso común rápido”
• Máquina registro-registro• Datos inmediatos en la propia instrucción
• La complejidad de las instrucciones es sólo un parámetro de diseño– Menor recuento de instrucciones, pero mayor CPI y mayor Tc
Curso 2005/2006 Fundamentos de Computadores 44
Otros puntos…• Gestión de procedimientos
– Enlazador (link)– Cargador (loader)– Gestión de la pila (stack)
• Bloque de activación• Puntero de marco (frame pointer)• Subrutinas recursivas
• Manipulación de cadenas (strings)• Punteros• Interrupciones y excepciones• Llamadas al sistema
Diseño del procesador
“Mientras el ENIAC está equipado con 18000 válvulas de vacio y pesa 30 toneladas, los ordenadores del futuro pueden tener 1000 válvulas y quizás pesen sólo 1 tonelada y
media.” Popular Mechanics, Marzo de 1949
Curso 2005/2006 Fundamentos de Computadores 2
Objetivos• Calcular el número total de ciclos de reloj de la ejecución de un trozo de código ensamblador para diferentes
implementaciones de un procesador básico • Trazar ciclo a ciclo de reloj (sobre una ruta de datos) un trozo de código ensamblador para diferentes
implementaciones de un procesador básico• Plantear una ruta de datos para un repertorio de instrucciones simple en un procesador básico• Modificar una ruta de datos para la inclusión de nuevas instrucciones en un procesador básico• Modificar una ruta de datos para satisfacer determinadas características de diseño• Especificar una unidad de control con una máquina de estados finitos para una ruta de datos y un repertorio de
instrucciones simples• Modificar una unidad de control específica de un procesador básico para la inclusión de nuevas instrucciones• Modificar una unidad de control específica de un procesador básico para satisfacer determinadas características• Calcular las ecuaciones de implementación de una unidad de control descrita mediante una máquina de estados
finitos• Rellenar el contenido de una memoria ROM para una especificación de una unidad de control mediante una
máquina de estados finitos• Implementar con PLA una especificación de una unidad de control mediante una máquina de estados finitos• Especificar la unidad de control de un procesador básico con un microprograma• Diseñar un formato de microinstrucciones para un procesador básico• Modificar un microprograma para la inclusión de nuevas instrucciones en un procesador básico• Modificar un microprograma para satisfacer determinadas características de diseño• Modificar el formato de microinstrucciones para un procesador básico• Escribir una rutina de tratamiento de excepción para interrupciones o excepciones básicas
Curso 2005/2006 Fundamentos de Computadores 3
Contenidos (1/4)
• Metodología de sincronización• Diseño de un procesador MIPS R3000
reducido– Rutas de datos individuales
• Búsqueda de instrucción• Decodificación de la instrucción• Ejecución (aritmético-lógicas, cargas y
almacenamientos, saltos condicionales y bifurcaciones)
Curso 2005/2006 Fundamentos de Computadores 4
Contenidos (2/4)• Diseño monociclo
– Diseño de la ruta de datos• Integración de las rutas de datos individuales• Señales de control• Integración de la ruta de datos y de la unidad de control• Ejemplos de flujo de datos + control
– Diseño de la unidad de control de la ALU (También válida para eldiseño multiciclo)
• Estructura de la ALU• Especificación del control ALU• Tabla de verdad del control ALU• Implementación del control ALU
– Diseño de la unidad de control• Funcionalidad de las señales de control• Implementación de la UC
– Ventajas y desventajas
Curso 2005/2006 Fundamentos de Computadores 5
Contenidos (3/4)• Diseño multiciclo
– Diseño de la ruta de datos• Esbozo de la ruta de datos• Integración de la ruta de datos y de la unidad de control• Etapa de la ejecución de las instrucciones
– Ejemplo de la ejecución de la instrucción lw– Diseño de la unidad de control
• Control cableado– Especificación de la UC con una FSM (diagrama)– Especificación de la UC con una FSM (tabla)– Implementación de la FSM– Ecuaciones de implementación de la FSM– Implementación de FSM con ROM– Implementación de FSM con PLA
• Control microprogramado– Formato de la microinstrucción– Señales asociadas a los campos y valores– Microprograma de la UC– Secuenciador del microprograma
Curso 2005/2006 Fundamentos de Computadores 6
Contenidos (4/4)
• Excepciones e interrupciones– Tratamiento de excepciones en MIPS– Implementación de excepciones en MIPS– Ruta de datos con soporte de excepciones– Especificación de la UC con soporte de
excepciones– Instrucciones para excepciones en MIPS
Curso 2005/2006 Fundamentos de Computadores 7
Metodología de sincronización• La metodología de sincronización define cuándo pueden leerse y
escribirse las diferentes señales• Características de la metodología de sincronización por nivel
– Un elemento de estado puede ser actualizado sólo en el flanco de reloj– Un elemento de estado puede ser leído y modificado en un mismo ciclo– Señales de habilitación de escritura explícitas
Stateelement
1
Stateelement
2
Combinationallogic
clock
one clock cycle
Curso 2005/2006 Fundamentos de Computadores 8
Diseño de un procesador MIPS R3000 reducido
• Soporte del subconjunto de instrucciones– Acceso a memoria: lw (load word) y sw (store word)– Aritmético-lógicas: add, sub, and, or, slt– Salto y bifurcación: beq (branch if equal) y j (jump)
• Ciclo de instrucción– Lectura de la instrucción M[PC]– Decodificación de la instrucción y lectura de los
registros– Ejecución de la instrucción
Curso 2005/2006 Fundamentos de Computadores 9
Ruta de datos individuales –Búsqueda de la instrucción
• Lectura de la memoria de instrucciones• Actualización del PC a la siguiente instrucción
ReadAddress
Instruction
InstructionMemory
Add
PC
4
Curso 2005/2006 Fundamentos de Computadores 10
Ruta de datos individuales –Decodificación de la instrucción
• Envío de los campos de código de operación y función a la unidad de control
• Lectura del banco de registro de los registros $rs y $rt
Instruction
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ControlUnit
Curso 2005/2006 Fundamentos de Computadores 11
Ruta de datos individuales –Aritmético-lógicas (ejecución)
• op y funct especifican la operación aritmético-lógica
• Escritura del registro $rd del banco de registros con la salida de la ALU
R-type:31 25 20 15 5 0
op rs rt rd functshamt
10
R-type:31 25 20 15 5 0
op rs rt rd functshamt
10
Instruction
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
overflowzero
ALU controlRegWrite
Curso 2005/2006 Fundamentos de Computadores 12
Ruta de datos individuales– Cargas y almacenamientos (ejecución)
• Cálculo de la dirección de memoria– address $rs + extensión-signo(IR[15:0])
• Carga de un registro (load)– $rt M[$rs + extensión-signo(IR[15:0])]
• Almacenamiento de un registro (store)– M[$rs + extensión-signo(IR[15:0])] $rt
Instruction
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
overflowzero
ALU controlRegWrite
DataMemory
Address
Write Data
Read Data
SignExtend
MemWrite
MemRead
Instruction
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
overflowzero
ALU controlRegWrite
DataMemory
Address
Write Data
Read Data
SignExtend
MemWrite
MemRead16 3216 32
Curso 2005/2006 Fundamentos de Computadores 13
Ruta de datos individuales – Saltos condicionales (ejecución)
• Resta de $rs y $rt y comprobación de la señal zero de la ALU
• Cálculo de la dirección efectiva de salto– address PC + 4 + extensión-signo(IR[15:0]<<2)
Instruction
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ALU
zero
ALU control
SignExtend16 32
Shiftleft 2
Add
4 Add
PC
Branchtargetaddress
(to branch control logic)
Curso 2005/2006 Fundamentos de Computadores 14
Ruta de datos individuales –Bifurcaciones (ejecución)
• Reemplazo del PC por la dirección efectiva de salto– PC PC[31:28] || (IR[25:0]<<2)
ReadAddress
Instruction
InstructionMemory
Add
PC
4
Shiftleft 2
Jumpaddress
26
4
28
Curso 2005/2006 Fundamentos de Computadores 15
Diseño monociclo
• Integración de las rutas de datos individuales– Recursos hardware + multiplexores + señales de
control + restricciones de diseño• Restricción de diseño
– Todas las instrucciones tardan un único ciclo de reloj– La instrucción más lenta determina el tiempo de ciclo– Ningún componente de la ruta de datos puede ser
reutilizado• Memorias separadas de instrucciones y datos• Sumadores…
Curso 2005/2006 Fundamentos de Computadores 16
Diseño de la RD - Integración de las individuales (no beq, no j)
MemtoReg
ReadAddress
Instruction
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovfzero
ALU controlRegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemReadSign
Extend16 32
ALUSrc MemtoRegMemtoRegMemtoReg
ReadAddress
Instruction
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovfzero
ALU controlRegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemReadSign
Extend16 32
ReadAddress
Instruction
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovfzero
ALU controlRegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemReadSign
Extend16 32
ALUSrcALUSrc
Curso 2005/2006 Fundamentos de Computadores 17
Diseño de la RD – Señales de control
• Selección de la operación a realizar– Operación ALU: ALUControl– Escritura y lectura del banco de registros: RegWrite– Escritura y lectura de las memorias: MemRead, MemWrite
• Selección de entradas de los multiplexores (flujo de datos)– ALUSrc, MemToReg
I-Type: op rs rt address offset31 25 20 15 0
R-type:31 25 20 15 5 0
op rs rt rd functshamt
10
J-type:31 25 0
op target addressJ-type:31 25 0
op target address
Curso 2005/2006 Fundamentos de Computadores 18
Diseño de la RD – Integración de la RD y de la UC
ReadAddress
Instr[31-0]
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovf
zero
RegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemRead
SignExtend16 32
MemtoReg
ALUSrc
Shiftleft 2
Add
PCSrc
RegDst
ALUcontrol
1
1
1
00
0
0
1
ALUOp
Instr[5-0]
Instr[15-0]
Instr[25-21]
Instr[20-16]
Instr[15 -11]
ControlUnit
Instr[31-26]
Branch
Curso 2005/2006 Fundamentos de Computadores 19
Diseño de la RD – Flujo de datos y control para tipo R
ReadAddress
Instr[31-0]
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovf
zero
RegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemRead
SignExtend16 32
MemtoReg
ALUSrc
Shiftleft 2
Add
PCSrc
RegDst
ALUcontrol
1
1
1
00
0
0
1
ALUOp
Instr[5-0]
Instr[15-0]
Instr[25-21]
Instr[20-16]
Instr[15 -11]
ControlUnit
Instr[31-26]
Branch
Curso 2005/2006 Fundamentos de Computadores 20
Diseño de la RD – Flujo de datos y control para lw
ReadAddress
Instr[31-0]
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovf
zero
RegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemRead
SignExtend16 32
MemtoReg
ALUSrc
Shiftleft 2
Add
PCSrc
RegDst
ALUcontrol
1
1
1
00
0
0
1
ALUOp
Instr[5-0]
Instr[15-0]
Instr[25-21]
Instr[20-16]
Instr[15 -11]
ControlUnit
Instr[31-26]
Branch
Curso 2005/2006 Fundamentos de Computadores 21
Diseño de la RD – Flujo de datos y control para beq
ReadAddress
Instr[31-0]
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovf
zero
RegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemRead
SignExtend16 32
MemtoReg
ALUSrc
Shiftleft 2
Add
PCSrc
RegDst
ALUcontrol
1
1
1
00
0
0
1
ALUOp
Instr[5-0]
Instr[15-0]
Instr[25-21]
Instr[20-16]
Instr[15 -11]
ControlUnit
Instr[31-26]
Branch
Curso 2005/2006 Fundamentos de Computadores 22
Integración de la RD – Flujo de datos y control para j
ReadAddress
Instr[31-0]
InstructionMemory
Add
PC
4
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
ovf
zero
RegWrite
DataMemory
Address
Write Data
Read Data
MemWrite
MemRead
SignExtend16 32
MemtoReg
ALUSrc
Shiftleft 2
Add
PCSrc
RegDst
ALUcontrol
1
1
1
00
0
0
1
ALUOp
Instr[5-0]
Instr[15-0]
Instr[25-21]
Instr[20-16]
Instr[15 -11]
ControlUnit
Instr[31-26]
Branch
Shiftleft 2
0
1
Jump
32Instr[25-0]
26PC+4[31-28]
28
Curso 2005/2006 Fundamentos de Computadores 23
Diseño de la UC de la ALU –Estructura de la ALU
Entradas de control(ALUctr) FUNCIÓN
000 AND001 OR010 ADD110 SUB111 SLT
A L U R e s u ltZ e r o
O v e r f lo w
a
b
A L U o p e r a t io n
C a r r y O u t
A L U R e s u ltZ e r o
O v e r f lo w
a
b
A L U o p e r a t io n
C a r r y O u t
0
3
Result
Operation
a
1
CarryIn
CarryOut
0
1
Binvert
b 2
Less
a.
0
3
Result
Operation
a
1
CarryIn
CarryOut
0
1
Binvert
b 2
Less
a.
Curso 2005/2006 Fundamentos de Computadores 24
Diseño de la UC de la ALU –Especificación del control ALU
• Operación ALU– lw, sw ($rs + extensión-signo(IR[15:0]))– beq ($rs-$rt)– add, sub, or, and y slt (operación específica)
Cod. Op. ALUop Instrucción FUNCT Op. deseada Entradas de control de la ALU (ALUctr)
LW 00 Carga XXXXXX suma 010
SW 00 Almacena XXXXXX suma 010
Branch Equal 01 salto XXXXXX resta 110
R-Type 10 suma 100000 suma 010
R-Type 10 resta 100010 resta 110
R-Type 10 AND 100100 and 000
R-Type 10 OR 100101 or 001
R-Type 10 set on less than 101010 set on less than 111
Curso 2005/2006 Fundamentos de Computadores 25
Diseño de la UC de la ALU – Tabla de verdad del control ALU
ALUop funct ALUctrALUop1 ALUop0 F5 F4 F3 F2 F1 F0 bit2 bit1 bit0
0 0 x x x x x x 0 1 0x 1 x x x x x x 1 1 01 x x x 0 0 0 0 0 1 01 x x x 0 0 1 0 1 1 01 x x x 0 1 0 0 0 0 01 x x x 0 1 0 1 0 0 11 x x x 1 0 1 0 1 1 1
MainControl
op6
ALUControl(Local)
func
N
6ALUop
ALUctr3
AL
Uop rs rt rd shamt funct
061116212631
6 bits 6 bits5 bits5 bits5 bits5 bits
Instrucción Tipo R:
funct<3:0> Instruction Op.00000010010001011010
addsubtractandorset-on-less-than
ALUop funct ALUctrALUop1 ALUop0 F5 F4 F3 F2 F1 F0 bit2 bit1 bit0
0 0 x x x x x x 0 1 0x 1 x x x x x x 1 1 01 x x x 0 0 0 0 0 1 01 x x x 0 0 1 0 1 1 01 x x x 0 1 0 0 0 0 01 x x x 0 1 0 1 0 0 11 x x x 1 0 1 0 1 1 1
MainControl
op6
ALUControl(Local)
func
N
6ALUop
ALUctr3
AL
U
MainControl
op6
ALUControl(Local)
func
N
6ALUop
ALUctr3
AL
Uop rs rt rd shamt funct
061116212631
6 bits 6 bits5 bits5 bits5 bits5 bits
Instrucción Tipo R: op rs rt rd shamt funct061116212631
6 bits 6 bits5 bits5 bits5 bits5 bits
Instrucción Tipo R:
funct<3:0> Instruction Op.00000010010001011010
addsubtractandorset-on-less-than
funct<3:0> Instruction Op.00000010010001011010
addsubtractandorset-on-less-than
Curso 2005/2006 Fundamentos de Computadores 26
Diseño de la UC de la ALU -Implementación del control ALU
ALUop funct Operación (ALUctr)ALUop1 ALUop0 F5 F4 F3 F2 F1 F0 bit2 bit1 bit0
0 0 x x x x x x 0 1 0x 1 x x x x x x 1 1 01 x x x 0 0 0 0 0 1 01 x x x 0 0 1 0 1 1 01 x x x 0 1 0 0 0 0 01 x x x 0 1 0 1 0 0 11 x x x 1 0 1 0 1 1 1
Operation2
Operation1
Operation0
Operation
ALUOp1
F3
F2
F1
F0
F (5– 0)
ALUOp0
ALUOp
ALU control block
Operation2
Operation1
Operation0
Operation
ALUOp1
F3
F2
F1
F0
F (5– 0)
ALUOp0
ALUOp
ALU control block
Curso 2005/2006 Fundamentos de Computadores 27
Diseño de la UC de la ALU – Unidad de control
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction [20–16]
Instruction [25–21]
Add
Instruction [5–0]
RegWrite
4
16 32Instruction [15–0]
0Registers
WriteregisterWritedata
Writedata
Readdata1
Readdata2
Readregister1Readregister2
Signextend
ALUresult
Zero
Datamemory
Address Readdata Mu
x
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction [15–11]
ALUcontrol
Shiftleft 2
PCSrc
ALU
Add ALUresult
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction [20–16]
Instruction [25–21]
Add
Instruction [5–0]
RegWrite
4
16 32Instruction [15–0]
0Registers
WriteregisterWritedata
Writedata
Readdata1
Readdata2
Readregister1Readregister2
Signextend
ALUresult
Zero
Datamemory
Address Readdata Mu
x
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction [15–11]
ALUcontrol
Shiftleft 2
PCSrc
ALU
Add ALUresult
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction [20–16]
Instruction [25–21]
Add
Instruction [5–0]
RegWrite
4
16
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction [20–16]
Instruction [25–21]
Add
Instruction [5–0]
RegWrite
4
16 32Instruction [15–0]
0Registers
WriteregisterWritedata
Writedata
Readdata1
Readdata2
Readregister1Readregister2
Signextend
ALUresult
Zero
Datamemory
Address Readdata Mu
x
1
1
Mux
32Instruction [15–0]
0Registers
WriteregisterWritedata
Writedata
Readdata1
Readdata2
Readregister1Readregister2
Signextend
ALUresult
Zero
Datamemory
Address Readdata Mu
x
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction [15–11]
ALUcontrol
Shiftleft 2
PCSrc
ALU
Add ALUresult
Tipo R: op rs rt rd shamt funct Bits: 31-26 25-21 20-16 15-11 10-6 5-0 Tipo I: op rs rt Inmediato16 Bits: 31-26 25-21 20-16 15-0 Tipo J: op Dirección Bits: 31-26 26-0
Curso 2005/2006 Fundamentos de Computadores 28
Diseño de la UC – Funcionalidad de las señales de control
Señal Acción cuando es desactivada (0) Acción cuando se activa (1)RegDst El registro destino para las escrituras viene del
campo rt (bits 20-16)El registro destino para las escrituras viene del campord (bits 15-11)
RegWrite Ninguno Escribe el dato en "WriteData" en el registro dado por"WriteRegister".
AluSrc El segundo operando de la ALU viene del banco deregistro (salida 2)
El segundo operando de la ALU son los 16 bits menossignificativos de la instrucción extendidos en signo
PCSrc Selecciona PC+4 como nuevo valor del PC Selecciona la dirección de salto computada como nuevovalor del PC
MemWrite Ninguna Escribe en la dirección de memoria "Address" el dato"WriteData"
MemRead Ninguna Lee un dato de la dirección de memoria "Address" y lodeja en la salida "ReadData"
MemToReg El valor a realimentar al campo "WriteData" vienede la salida de la ALU
El valor a realimentar al campo "WriteData" viene de lamemoria
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction[20–16]
Instruction[25–21]
Add
Instruction[5–0]
RegWrite4
16 32Instruction[15–0]0
Registers
WriteregisterWritedata
Writedata
Readdata1Read
data2
Readregister1Readregister2
Signextend
ALUresultZero
Datamemory
Address Readdata Mux
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction[15–11]
ALUcontrol
Shiftleft2
PCSrc
ALU
Add ALUresult
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction[20–16]
Instruction[25–21]
Add
Instruction[5–0]
RegWrite4
16 32Instruction[15–0]0
Registers
WriteregisterWritedata
Writedata
Readdata1Read
data2
Readregister1Readregister2
Signextend
ALUresultZero
Datamemory
Address Readdata Mux
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction[15–11]
ALUcontrol
Shiftleft2
PCSrc
ALU
Add ALUresult
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction[20–16]
Instruction[25–21]
Add
Instruction[5–0]
RegWrite4
16
MemtoReg
MemRead
MemWrite
ALUOp
ALUSrc
RegDst
PC
Instructionmemory
Readaddress
Instruction[31–0]
Instruction[20–16]
Instruction[25–21]
Add
Instruction[5–0]
RegWrite4
16 32Instruction[15–0]0
Registers
WriteregisterWritedata
Writedata
Readdata1Read
data2
Readregister1Readregister2
Signextend
ALUresultZero
Datamemory
Address Readdata Mux
1
1
Mux
32Instruction[15–0]0
Registers
WriteregisterWritedata
Writedata
Readdata1Read
data2
Readregister1Readregister2
Signextend
ALUresultZero
Datamemory
Address Readdata Mux
1
1
Mux
0
1
Mux
0
1
Mux
0
Instruction[15–11]
ALUcontrol
Shiftleft2
PCSrc
ALU
Add ALUresult
Curso 2005/2006 Fundamentos de Computadores 29
Diseño de la UC – Implementación de la UC
Op5-0 ->(bits 31-26)
00 00000D
10 001135D
10 101143D
00 01004D
R-Format lw sw beqRegDst 1 0 x xALUSrc 0 1 1 0MemToReg 0 1 x xRegWrite 1 1 0 0MemRead 0 1 0 0MemWrite 0 0 1 0Branch 0 0 0 1ALUOp1 1 0 0 0ALUOp0 0 0 0 1
R-format Iw sw beq
Op0Op1Op2Op3Op4Op5
Inputs
Outputs
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
Implementación con PLA
R-format Iw sw beq
Op0Op1Op2Op3Op4Op5
Inputs
Outputs
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
R-format Iw sw beq
Op0Op1Op2Op3Op4Op5
Inputs
Outputs
RegDst
ALU
R-format Iw sw beq
Op0Op1Op2Op3Op4Op5
Inputs
Outputs
RegDst
ALUSrc
MemtoReg
RegWrite
MemRead
MemWrite
Branch
ALUOp1
ALUOpO
Implementación con PLA
Curso 2005/2006 Fundamentos de Computadores 30
Diseño monociclo – Ventajas y desventajas
• Todas las instrucciones tardan un ciclo• Aprovechamiento ineficiente del área del chip (componentes
repetidos) • Ciclo de reloj grande para acomodar la instrucción más lenta
– Las instrucciones de punto flotante requerirían un tiempo de ciclo extra largo
Clk
lw sw Waste
Cycle 1 Cycle 2Clk
lw sw Waste
Cycle 1 Cycle 2
Curso 2005/2006 Fundamentos de Computadores 31
Diseño multiciclo
• División del ciclo de instrucción en etapas (cada etapa un ciclo de reloj)– CPI (ciclos por instrucción) variables (instrucciones
lentas y rápidas)– Las etapas presentan cargas de trabajo equilibradas
• Reutilización de las unidades funcionales– Memoria unificada, pero un único acceso por ciclo– Una única ALU, pero una única operación ALU por
ciclo
Curso 2005/2006 Fundamentos de Computadores 32
Diseño de la RD – Esbozo de la ruta de datos
• Inclusión de registros a la salida de las unidades funcionales para preservar los datos (generalmente entre ciclos adyacentes)
– IR, registro de instrucciones – MDR, registro de dato leído de memoria – A, B registros de datos leídos desde el banco de registro– ALUOut, registro de salida de la ALU
• IR actualiza el contenido cada instrucción, el resto de los registros cada ciclo de reloj
AddressRead Data
(Instr. or Data)
Memory
PC
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
Write Data
IRM
DR
AB A
LUou
tAddressRead Data
(Instr. or Data)
Memory
PC
Write Data
Read Addr 1
Read Addr 2
Write Addr
Register
File
ReadData 1
ReadData 2
ALU
Write Data
IRM
DR
AB A
LUou
t
Curso 2005/2006 Fundamentos de Computadores 33
Diseño de la RD – Integración de la RD y de la UC (1/2)
• Los multiplexores a las entradas de las unidades funcionales y la ejecución multiciclo permiten el compartimiento de los recursos hardware
Shiftleft 2
MemtoReg
IorD MemRead MemWrite
PC
Memory
MemData
Writedata
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
ALUOpALUSrcB
RegDst RegWrite
Instruction[15– 0]
Instruction [5– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
1 Mux
0
32
ALUcontrol
Mux
0
1ALU
resultALU
ALUSrcA
ZeroA
B
ALUOut
IRWrite
Address
Memorydata
register Shiftleft 2
MemtoReg
IorD MemRead MemWrite
PC
Memory
MemData
Writedata
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–
Shiftleft 2
MemtoReg
IorD MemRead MemWrite
PC
Memory
MemData
Writedata
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
ALUOpALUSrcB
RegDst RegWrite
Instruction[15– 0]
Instruction [5– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
1 Mu
11]
Mux
0
1
Mux
0
1
4
ALUOpALUSrcB
RegDst RegWrite
Instruction[15– 0]
Instruction [5– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
1 Mux
0
32
ALUcontrol
Mux
0
1ALU
resultALU
ALUSrcA
ZeroA
B
ALUOut
IRWrite
Address
Memorydata
register
Curso 2005/2006 Fundamentos de Computadores 34
Diseño de la RD – Integración de la RD y de la UC (2/2)
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
Memory
MemData
Writedata
Address
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signe
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
Io
xtend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instructi
rD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
Memory
MemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 35
Diseño de la RD - Etapas de la ejecución de las instrucciones
(1/3)1. Búsqueda de la instrucción y
actualización del PC (IF)IR M[PC]; PC PC + 4
2. Decodificación instrucción, lectura de registros y cálculo de dirección efectiva de salto (DEC/REG)
A RegFile[$rs]; B RegFIle[$rt]; ALUOut PC + extensión-signo(IR[15:0])<<2
Curso 2005/2006 Fundamentos de Computadores 36
Diseño de la RD - Etapas de la ejecución de las instrucciones
(2/3)3. Ejecución (EX)
– Tipo R (add, sub, and, or, slt)ALUOut A op B
– Referencia a memoria (lw, sw)ALUOut A + extensión-signo(IR[15:0])
– Salto (beq) if (A=B) PC ALUOut
– Bifurcación (j)PC PC[31:28] || IR[25:0]<<2
Curso 2005/2006 Fundamentos de Computadores 37
Diseño de la RD - Etapas de la ejecución de las instrucciones
(3/3)4. Acceso a memoria o fin ejecución tipo R
(MEM)– Acceso a memoria para lectura
MDR M[ALUOut]– Acceso a memoria para escritura
M[ALUOut] B– Fin ejecución tipo R
$rd ALUOut
5. Fin de lectura en memoria (WB)MDR M[ALUOut]
Curso 2005/2006 Fundamentos de Computadores 38
Etapas de la ejecución de las instrucciones - lw
Etapa IF
Shiftleft 2
PCMux
0
1RegistersWrite
register
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–11]
Mux
0
1
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25–21]
Instruction[20–16]
Instruction[15–0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorDMemReadMemWrite
MemtoReg
PCWriteCondPCWrite
IRWrite
ALUOp
ALUSrcBALUSrcA
RegDst
PCSource
RegWriteControl
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5–0]
Mux
0
2
Jumpaddress [31-0]Instruction [25–0] 26 28Shift
left 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
MemoryMemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 39
Etapas de la ejecución de las instrucciones - lwEtapa DEC/REG
Shiftleft 2
PCMux
0
1RegistersWrite
register
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–11]
Mux
0
1
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25–21]
Instruction[20–16]
Instruction[15–0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorDMemReadMemWrite
MemtoReg
PCWriteCondPCWrite
IRWrite
ALUOp
ALUSrcBALUSrcA
RegDst
PCSource
RegWriteControl
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5–0]
Mux
0
2
Jumpaddress [31-0]Instruction [25–0] 26 28Shift
left 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
MemoryMemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 40
Etapas de la ejecución de las instrucciones - lw
Etapa EX
Shiftleft 2
PCMux
0
1Registers
Writeregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–11]
Mux
0
1
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25–21]
Instruction[20–16]
Instruction[15–0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorDMemRead
MemWrite
MemtoReg
PCWriteCondPCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWriteControl
Outputs
Op[5–0]
Instruction[31-26]
Instruction [5–0]
Mux
0
2
Jumpaddress [31-0]Instruction [25–0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
MemoryMemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 41
Etapas de la ejecución de las instrucciones - lw
Etapa MEM
Shiftleft 2
PCMux
0
1RegistersWrite
register
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–11]
Mux
0
1
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25–21]
Instruction[20–16]
Instruction[15–0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorDMemReadMemWrite
MemtoReg
PCWriteCondPCWrite
IRWrite
ALUOp
ALUSrcBALUSrcA
RegDst
PCSource
RegWriteControl
Outputs
Op[5–0]
Instruction[31-26]
Instruction [5–0]
Mux
0
2
Jumpaddress [31-0]Instruction [25–0] 26 28Shift
left 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
MemoryMemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 42
Etapas de la ejecución de las instrucciones - lw
Etapa WB
Shiftleft 2
PCMux
0
1RegistersWrite
register
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15–11]
Mux
0
1
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25–21]
Instruction[20–16]
Instruction[15–0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorDMemReadMemWrite
MemtoReg
PCWriteCondPCWrite
IRWrite
ALUOp
ALUSrcBALUSrcA
RegDst
PCSource
RegWriteControl
Outputs
Op[5–0]
Instruction[31-26]
Instruction [5–0]
Mux
0
2
Jumpaddress [31-0]Instruction [25–0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
32
Mux
0
1ALUOut
MemoryMemData
Writedata
Address
Curso 2005/2006 Fundamentos de Computadores 43
Diseño multiciclo - Diseño de la unidad control
• Máquina de estados finitos (FSM)– Especificación del control mediante un diagrama de estados
finitos (representación gráfica o tabular)– Máquina de estados finitos
• Conjunto de estados• Función estado siguiente
– Si ×Ij Sk
• Función salida – Máquinas de Moore: Si Ok– Máquinas de Mealy: Si ×Ij Ok
• Microprogramación– Especificación del control mediante un programa– Necesaria para simplificar la especificación de una UC compleja
Curso 2005/2006 Fundamentos de Computadores 44
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst = 0RegWrite
MemtoReg =1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
= 'BEQ')
(Op
='J
')(Op = 'SW
')
(Op
='L
W')
4
01
9862
753
Start
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1AL PCWrite
PCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst = 0RegWrite
MemtoReg =1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchIn
USrcB = 10ALUOp = 00
RegDst = 0RegWrite
MemtoReg =1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R
struction decode/register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
= 'BEQ')
(Op
='J
')(Op = 'SW
')
(Op
='L
W')
4
01
9862
753
Start
Control cableado - Especificación de la UC con una FSM (diagrama)
Curso 2005/2006 Fundamentos de Computadores 45
Control cableado - Especificación de la UC con una FSM (tabla)
Entradas SalidasCódigo Operación Estado Actual Estado
Siguiente Señales de Control para el Camino de Datos
op5 op
4
op3
op2
op1
op0
s3 s2 s1 s0 ns3
ns2
ns1
ns0
pCW
rite
PC
Writ
eCon
d
IorD
Mem
Rea
d
Mem
Writ
e
IRW
Rite
Mem
ToR
eg
PC
Sou
rce1
PC
Sou
rce0
ALU
Op1
ALU
op0
ALU
SrcB
1
ALU
SrcB
0
ALU
SrcA
Reg
writ
e
Reg
Dst
0 x x x x x x 0 0 0 0 0 0 0 1 1 0 0 1 0 1 0 0 0 0 0 0 1 0 0 0
1 lw 1 0 0 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
1 sw 1 0 1 0 1 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
1 R 0 0 0 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
1 beq 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
1 j 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
2 lw 1 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 02 sw 1 0 1 0 1 1 0 0 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 03 x x x x x x 0 0 1 1 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 04 x x x x x x 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 05 x x x x x x 0 1 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 06 x x x x x x 0 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 1 0 07 x x x x x x 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 18 x x x x x x 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 1 0 09 x x x x x x 1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
Curso 2005/2006 Fundamentos de Computadores 46
Control cableado – Implementación de la FSM
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1
S0
State register
IRWrite
MemReadMemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
Estado Siguiente
Estado Actual
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1
S0
State register
IRWrite
MemReadMemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1
S0
State register
IRWrite
MemReadMemWrite
Instruction r
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1
S0
State register
IRWrite
MemReadMemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
Estado Siguiente
Estado Actual
Curso 2005/2006 Fundamentos de Computadores 47
Control cableado – Ecuaciones de implementación de la FSM
Señal Control Ecuación lógicaNS3 -> (S3'S2'S1'S0) (OP5'OP4'OP3'OP2OP1'OP0') + (S3'S2'S1'S0) (OP5'OP4'OP3'OP2'OP1OP0') =
Estado 1 (op[5:0] = 'beq') + Estado 1 (op[5:0] = 'jmp')NS2 -> Estado 1 (op[5:0] = 'R-format') + Estado 2 (op[5:0] = 'sw') + Estado 3 + Estado 6
NS1 -> Estado 1 (op[5:0] = 'lw') + Estado 1 (op[5:0] = 'sw') + Estado 1 (op[5:0] = 'R-format') +Estado 2 (op[5:0] = 'lw') + Estado 2 (op[5:0] = 'sw') + Estado 6
NS0 -> Estado 0 + Estado 1 (op[5:0] = 'jmp') + Estado 2 (op[5:0] = 'lw') + Estado 2 (op[5:0] = 'sw') + Estado 6
PCWrite -> Estado 0 + Estado 9
PCWriteCond -> Estado 8
IorD -> Estado 3 + Estado 5
MemRead -> Estado 0 + Estado 3
MemWrite -> Estado 5
IRWrite -> Estado 0
MemToReg -> Estado 4
PCSource1 -> Estado 9
PCSource0 -> Estado 8
ALUOp1 -> Estado 6
ALUOp0 -> Estado 8
ALUSrcB1 -> Estado 1 + Estado 2
ALUSrcB0 -> Estado 0 + Estado 1
ALUSrcA -> Estado 2 + Estado 6 + Estado 8
RegWrite -> Estado 4 + Estado 7
RegDst -> Estado 7
Curso 2005/2006 Fundamentos de Computadores 48
Control cableado - Implementación de FSM con ROM
• Diseño unificado (Tamaño 210 × 20 = 20Kb)
– 6 bits código de operación + 4 bits de los estados = 210 posiciones de memoria
– 16 salidas de control + 4 salidas de nuevo estado = 20 bits de anchura
• Diseño no unificado (Tamaño 4.25Kb)– ROM de señales de control (Tamaño
24 × 16 = 256b)• 4 bits de los estados = 24 posiciones de
memoria• 16 salidas de control = 4 bits de
anchura– ROM de nuevo estado (Tamaño 210 × 4
= 4Kb)• 6 bits código de operación + 4 bits de
los estados = 210 posiciones de memoria
• 4 salidas de nuevo estado = 4 bits de anchura
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1 S0
State register
IRWrite
MemReadMemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
Tamaño:20 Kbits vs 4.25 Kbits
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1 S0
State register
IRWrite
MemReadMemWrite
Instruction r
PCWrite
PCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWriteRegDst
NS3NS2NS1NS0
Op5
Op4
Op3
Op2
Op1
Op0
S3 S2 S1 S0
State register
IRWrite
MemReadMemWrite
Instruction registeropcode field
Outputs
Control logic
Inputs
Tamaño:20 Kbits vs 4.25 Kbits
Curso 2005/2006 Fundamentos de Computadores 49
Control cableado - Implementación de FSM con PLA
• Tamaño de la PLA– #inputs × #minterms +
#outputs × #minterms= (10 × 17)+(20 × 17) = 510 celdas
Op5
Op4
Op3
Op2
Op1
Op0
S3
S2
S1
S0
IorD
IRWrite
MemReadMemWrite
PCWritePCWriteCond
MemtoRegPCSource1
ALUOp1
ALUSrcB0ALUSrcARegWriteRegDstNS3NS2NS1NS0
ALUSrcB1ALUOp0
PCSource0
Curso 2005/2006 Fundamentos de Computadores 50
Diseño de la unidad de control –Control microprogramado
• El estado siguientees frecuentemente el estado actual + 1
• Las señales de control están almacenadas en una memoria
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWrite
AddrCtl
Outputs
Microcode memory
IRWrite
MemReadMemWrite
RegDst
Control unit
Input
Microprogram counter
Address select logic
Op[
5–0]
Adder
1
Datapath
Instruction registeropcode field
BWrite
Secuenciadorexterno
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWrite
AddrCtl
Outputs
Microcode memory
IRWrite
MemReadMemWrite
RegDst
Control unit
Input
Microprogram counter
Address select logic
Op[
5–0]
Adder
1
Datapath
Instruction registeropcode field
BWrite
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWrite
AddrCtl
Outputs
Microcode memory
IRWrite
MemReadMemWrite
RegDst
Control unit
Input
Microprogram counter
Address select
PCWritePCWriteCondIorD
MemtoRegPCSourceALUOpALUSrcBALUSrcARegWrite
AddrCtl
Outputs
Microcode memory
IRWrite
MemReadMemWrite
RegDst
Control unit
Input
Microprogram counter
Address select logic
Op[
5–0]
Adder
1
Datapath
Instruction registeropcode field
BWrite
Secuenciadorexterno
Secuenciadorexterno
Curso 2005/2006 Fundamentos de Computadores 51
Control microprogramado –Formato de la microinstrucción
• 7 campos: 6 campos de control + 1 campo de secuenciación
ControlALU SRC1 SRC2 Control
Registro Memoria ControlPCWrite Secuenciamiento
Nombre del campo Función del campo Valores del campoControl ALU Especifica la operación que va a realizar la ALU
durante el ciclo.addsubtFunc code
SRC1 Especifica la fuente para el primer operando dela ALU
PCA
SRC2 Especifica la fuente para el segundo operandode la ALU
B4ExtendExtShft
Control Registro Especifica el número de registro y fuente deldato que se escribe en el mismo
ReadWrite ALU (rd <- ALUout)Write MDR (rt <- MDR)
Memoria Especifica lectura o escritura y la fuente de ladirección
Read PC (IR <- M[PC])Read ALU (MDR <- M[ALUout]Write ALU (M[ALUout] <- B)
Control PCWrite Especifica la escritura del PC ALUALUOut-CondJump Address
Secuenciamiento Especifica la siguiente microinstrucción que seva a ejecutar
SeqFetchDispatch i
Curso 2005/2006 Fundamentos de Computadores 52
Control microprogramado– Señales asociadas a los campos y valores
C o n tro l A L UA L U o p 1 A L U O p 0
O p e ra c ió n
0 0 S u m a0 1 R e s ta1 0 F u n c . c o d e
S R C 2A LU S rB 1 A LU S rcB 0
O perac ión
0 0 B0 1 41 0 E xtend1 1 E xtS h ft
R e g is te r C o n tro lR e g W rite R e g D s t M e m T o R e g
O p e r.
1 1 0 W rite A L U1 0 1 W rite M D R
M e m o riaIR W rite M e m R e a d M e m W rite Io rD
O p e r.
1 1 0 0 R e a d P C0 1 0 1 R e a d A L U0 0 1 1 W rite A L U
R e g is te r C o n tro lR e g W rite R e g D s t M e m T o R e g
O p e r.
1 1 0 W rite A L U1 0 1 W rite M D R
M e m o riaIR W rite M e m R e a d M e m W rite Io rD
O p e r.
1 1 0 0 R e a d P C0 1 0 1 R e a d A L U0 0 1 1 W rite A L U
Control PCWritePCSrc1 PcSrc0 PCwrite PCWrtCond
Oper.
0 0 1 0 ALU0 1 0 1 ALUOut-Cond1 0 1 0 Jump address
S ecA ddrC tl1 A ddrC tl0
O perac ión
1 1 S eq.0 0 Fetch0 1 D ispa tch11 0 D ispa tch2
Control PCWritePCSrc1 PcSrc0 PCwrite PCWrtCond
Oper.
0 0 1 0 ALU0 1 0 1 ALUOut-Cond1 0 1 0 Jump address
S ecA ddrC tl1 A ddrC tl0
O perac ión
1 1 S eq.0 0 Fetch0 1 D ispa tch11 0 D ispa tch2
S R C 1A d d rS rc A
O p e ra c ió n
0 P C1 A
Curso 2005/2006 Fundamentos de Computadores 53
Control microprogramado –Microprograma de la UC
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
SrcA
ALU
SrcB
1
ALU
SrcB
0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sour
ce1
PC
Sour
ce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
18 señales de control ->
Curso 2005/2006 Fundamentos de Computadores 54
Control microprogramado –Secuenciador del microprograma
• La lógica de selección de direcciones genera la dirección de la siguiente microinstrucción a ejecutar
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ecA ddrC tl1 A ddrC tl0
O perac ión
1 1 S eq.0 0 Fe tch0 1 D ispa tch11 0 D ispa tch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ecA ddrC tl1 A ddrC tl0
O perac ión
1 1 S eq.0 0 Fe tch0 1 D ispa tch11 0 D ispa tch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
Curso 2005/2006 Fundamentos de Computadores 55
Excepciones e interrupciones
• Definiciones– Eventos inesperados que cambian el flujo
normal de ejecución de las instrucciones– Excepción
• Evento que tiene su origen en el interior del procesador (desbordamiento aritmético, instrucción ilegal, etc.)
– Interrupción• Evento que tiene su origen en el exterior del
procesador (dispositivos de entrada/salida, fallo de página, etc.)
Curso 2005/2006 Fundamentos de Computadores 56
Tratamiento de excepciones en MIPS
• Acciones básicas– Guardar la dirección de la instrucción causante en el registro Contador
de Programa de Excepciones (EPC)– Registrar la causa de la excepción (Registro CAUSE)– Transferir el control al sistema operativo en alguna dirección
especificada (0xC0000000) donde se tratará la excepción (ejecución de una rutina de servicio)
Interrupción
Rutina de serviciode la interrupción
ProgramaInterrupción
Rutina de serviciode la interrupción
Programa
Curso 2005/2006 Fundamentos de Computadores 57
Implementación de excepciones en MIPS
• Excepciones a implementar– Desbordamiento aritmético – Instrucción ilegal o no definida
• Registros adicionales requeridos– EPC: registro de 32 bits para guardar la dirección de la instrucción
causante de la excepción– CAUSE: Registro de 32 bits para registrar la causa de la excepción.
Utilizaremos sólo el bit menos significativo• bit 0 = 0 -> Instrucción ilegal• bit 0 = 1 -> Desbordamiento aritmético
• Señales de control adicionales– Intcause (0: instr. ilegal; 1: desbordamiento)– CauseWrite (1: escritura en el registro CAUSE; 0: no escribe)– EPCWrite (1: escritura en el registro EPC; 0: no escribe)– Constante: C000 0000 0000 0000 (dirección a donde se
transfiere el control cada vez que se interrumpe)
Curso 2005/2006 Fundamentos de Computadores 58
Ruta de datos con soporte de excepciones
11
10
To state 0 to begin next instruction
�PC++Source = 11
�
ALUSrcA = 0�ALUSrcB = 01�ALUOp = 01�
EPCWrite�PCWrite�
�
�
�
IntCause = 0�CauseWrite
ALUSrcA = 0�ALUSrcB = 01�ALUOp = 01�
EPCWrite�PCWrite�
PCSource = 11�PCSource = 11
�
�
IntCause = 1�CauseWrite
Shiftleft 2
Memory
MemData
Writedata
Mux
0
1
Instruction[15– 11]
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
Address
EPC
CO 00 00 00 3
Cause
ALUOpALUSrcBALUSrcA
RegDst
PCSource
RegWrite
EPCWriteIntCauseCauseWrite
1
0
1 Mux
0
32
Mux
0
1
Mux
0
1
PC
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
ALUOut
Shiftleft 2
Memory
MemData
Writedata
Mux
0
1
Instruction[15– 11]
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0
Shiftleft 2
Memory
MemData
Writedata
Mux
0
1
Instruction[15– 11]
Mux
0
1
4
Instruction[15–0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
]Instruction
register
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
Address
EPC
CO 00 00 00 3
Cause
ALUOpALUSrcBALUSrcA
RegDst
PCSource
RegWrite
EPCWriteIntCause
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
Address
EPC
CO 00 00 00 3
Cause
ALUOpALUSrcBALUSrcA
RegDst
PCSource
RegWrite
EPCWriteIntCauseCauseWrite
1
0
1 Mux
0
32
Mux
0
1
Mux
0
1
PC
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
ALU
CauseWrite
1
0
1 Mux
0
32
Mux
0
1
Mux
0
1
PC
Mux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
ALUOut
Curso 2005/2006 Fundamentos de Computadores 59
Especificación de la UC con soporte de excepciones
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA = 1ALUSrcB = 00ALUOp = 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 00ALUOp = 00
RegWriteMemtoReg = 1
RegDst = 0
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
Register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op = 'BE
Q')
(Op
='J'
)
(Op = 'SW')
(Op
='L
W' )
4
01
9862
7 11 1053
Start
(Op =other)
Overflow
Overflow
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
IntCause = 0CauseWrite
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
IntCause = 1CauseWrite
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA = 1ALUSrcB = 00ALUOp = 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 00ALUOp =
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA = 1ALUSrcB = 00ALUOp = 10
RegDst = 1RegWrite
MemtoReg = 0MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 00ALUOp = 00
RegWriteMemtoReg = 1
RegDst = 0
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction de
00
RegWriteMemtoReg = 1
RegDst = 0
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
Register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op =
code/Register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op = 'BE
Q')
(Op
='J'
)
(Op = 'SW')
(Op
='L
W' )
4
01
9862
7 11 1053
Start
(Op =other)
Overflow
Overflow
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
IntCause = 0CauseWrite
A
'BEQ')
(Op
='J'
)
(Op = 'SW')
(Op
='L
W' )
4
01
9862
7 11 1053
Start
(Op =other)
Overflow
Overflow
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
IntCause = 0CauseWrite
ALUSrcA = 0ALUSrcB = 01ALUOp = 01
EPCWritePCWrite
PCSource = 11
IntCause = 1CauseWrite
PCWritePCSource = 10
Curso 2005/2006 Fundamentos de Computadores 60
Instrucciones para excepciones en MIPS
• mfc0 $rt, $rd (move from coprocesador 0)– Transfiere la información desde el registro de propósito general $rd al
registro de propósito especial $rt (0 para CAUSE, 1 para EPC) – Tipo R
• 010000 0000 ttttt ddddd 00000000000• mtc0 $rd, $rt (move to coprocesador 0)
– Transfiere la información desde el registro de propósito especial $rt (0 para CAUSE, 1 para EPC) al registro de propósito general $rd
– Tipo R• 010000 0100 ttttt ddddd 00000000000
• rfe (return from exception)– Transfiere el contenido del EPC al registro contador de programa– Tipo J
• 010000 10000000000000000000100000
Rendimiento, coste y prestaciones
“El tiempo descubre la verdad”, Séneca
Curso 2005/2006 Fundamentos de Computadores 2
Contenidos (1/3)• Métricas de rendimiento, coste y prestaciones• Definiciones
– Tiempo de respuesta, tiempo de CPU, productividad y rendimiento
• Medidas del rendimiento– MIPS, MFLOPS– Tiempo de ejecución– Ecuación clásica del tiempo de CPU
• Fórmula básica• CPImedio• Dependencias
Curso 2005/2006 Fundamentos de Computadores 3
Contenidos (2/3)• Programas para la evaluación del rendimiento - Benchmarks• SPEC Benchmarks
– SPEC’89– SPEC’92 y SPEC’95
• SpecInt, SpecFp, SPECbase• SPEC’95 – Programas• SPEC’95 – Pentium
– SPEC CPU2000• CINT2000, CFP2000 • Programas• SPEC CINT2000 y CFP2000 - Pentium
– SPECweb99• Sistemas Dell PowerEdge
– Benchmarks para embedded computing systems• Fiabilidad de los programas de prueba• Más métricas del rendimiento
– MIPS y MFLOPS
Curso 2005/2006 Fundamentos de Computadores 4
Contenidos (3/3)
• Métodos de comparación y resumen de rendimientos
• Ley de Amdahl (o ley de rendimientos decrecientes)
• Rendimiento, potencia y eficiencia de energía– Limitaciones de los sistemas empotrados y portátiles– Técnicas de ahorro de potencia– Familia Pentium
• Conclusiones
Curso 2005/2006 Fundamentos de Computadores 5
Objetivos• Definir coste, rendimiento, productividad y prestaciones• Dar las principales métricas para el coste, el rendimiento, productividad y
prestaciones y su importancia para los usuarios y diseñadores• Distinguir entre tiempo de ejecución del tiempo de CPU• Aplicar la ecuación básica del rendimiento• Señalar la influencia de los parámetros de diseño de un computador sobre
los parámetros de la ecuación básica del tiempo de CPU• Categorizar los diferentes programa para la evaluación del rendimiento• Conocer las características de las medidas de rendimiento SPECS, MIPS y
MFLOPS• Métodos de resumen de rendimientos• Aplicar la ley de Amdahl para el cálculo del rendimiento• Enumerar las principales limitaciones de los sistemas empotrados y
portátiles eficiencia de energía
Curso 2005/2006 Fundamentos de Computadores 6
Métricas de rendimiento, coste y prestaciones
• Métricas del rendimiento– Tiempo de respuesta, productividad…
• Métricas del coste– Generalmente €, $...,
• Métricas de las prestaciones– Relación entre rendimiento y productividad
• Importan a los clientes y vendedores de computadores– ¿Qué máquina proporciona el mayor rendimiento?– ¿Qué máquina tiene el menor coste?– ¿Qué máquina tiene la mejor relación rendimiento/coste?
• Importan a lo diseñadores de computadores– ¿Qué diseño proporciona mayor rendimiento?– ¿Qué diseño tiene menor coste?– ¿Qué diseño tiene la mejor relación rendimiento/coste?
Curso 2005/2006 Fundamentos de Computadores 7
Definiciones -Tiempo de respuesta, tiempo de CPU y productividad
• Tiempo de respuesta o latencia o tiempo de ejecución– Tiempo entre el comienzo y finalización de una tarea
• Tiempo de CPU– No incluye tiempo de: accesos a memoria secundaria
y discos, entrada y salida, otros procesos…• Productividad (throughput)
– Cantidad total de trabajo realizado por unidad de tiempo
Curso 2005/2006 Fundamentos de Computadores 8
Tiempo de respuesta y productividad - Ejemplos
• Un tren de lavado de coches comienza un coche nuevo cada 30s y en el tren de lavado coexisten 6 coches en distintas fases de lavado – Tiempo de respuesta (usuario) de 180s (30*6)– Productividad de 1 coche/30 segundos
• El cambio de procesador de un computador ¿disminuye el tiempo de respuesta, aumenta la productividad o ambos?
• La adición de procesadores a un computador que asigna un procesador a cada tarea ¿disminuye el tiempo de respuesta, aumenta la productividad o ambos?
Curso 2005/2006 Fundamentos de Computadores 9
Definición de rendimiento
• El rendimiento de un computador es el inverso del tiempo de ejecución
– Un computador X es n veces más rápido que un computador Y cuando
– Un computador X (Y) es n% veces más rápido (lento) que un computador Y (X) cuando
XX ejecución de Tiempo
1oRendimient =
n=Y
X
oRendimientoRendimient
n=− 100*
oRendimientoRendimientoRendimient
Y
YX n=− 100*
oRendimientoRendimientoRendimient
X
YX
Curso 2005/2006 Fundamentos de Computadores 10
Definición de rendimiento - Ejemplo
• La máquina A ejecuta un programa en 10s y la máquina B ejecuta el mismo programa en 15 s,– ¿cuánto más rápida es A respecto de B?
– ¿cuánto más lenta es B respecto de A?
%50
151
151
101
100%1
11
100%100% =−
=
−
=−
=
B
BA
CPU
CPUCPU
B
BA
T
TTR
RRn
%3.33
101
151
101
100%1
11
100%100% =−
=
−
=−
=
A
BA
CPU
CPUCPU
A
BA
T
TTR
RRn
Curso 2005/2006 Fundamentos de Computadores 11
• MIPS (Million Instructions Per Second )• MFLOPS (Millions of Floating Point Operations Per Second )
– TOP 1 de 2005: IBM BlueGene/L 280600 GFLOPS y 131072 P– TOP 8 de 2005: IBM Mare Nostrum 27910 GLOPS con 4800 P
• Frecuencia del reloj (MHz, GHz) inversa del periodo de reloj
– A 4GH = 250ps• Tiempo de ejecución
– MIPS, MFLOPS… no son medidas fiables– El tiempo es la única medida fiable del rendimiento de un computador– Medida del tiempo
• El sistema operativo UNIX proporciona la orden time “nombre de programa”para medir el tiempo
• Ejemplo de salida de time: 90.7u 12.9s 2:39s 65%
one clock period
Medidas del rendimiento
Curso 2005/2006 Fundamentos de Computadores 12
Ecuación clásica del TCPU -Fórmula básica
• El tiempo de CPU es el tiempo que la CPU tarda en la ejecución de un programa
• Ciclos por instrucción (medio)
• Tiempo de CPU = # de instrucciones por programa × Ciclos por instrucción (medio) × Tiempo de ciclo
ciclo de Tiempoprogramapor reloj de ciclos# ×=CPUT
nesinstruccio#programapor reloj de ciclos#
=medioCPI
CCPU TCPINT ××=
Curso 2005/2006 Fundamentos de Computadores 13
Ecuación clásica del TCPU - CPImedio
• El cálculo del CPImedio considera los tipos, los CPI individuales y los promedios de uso de las instrucciones
– ICi es el porcentaje del # de instrucciones de tipo-i ejecutadas
– CPIi es el # de ciclos de reloj por instrucción del tipo-i– n es el # de instrucciones
• CPImedio varía con los programas y los datos de entrada
∑=
×=n
iiimedio ICCPICPI
1
Curso 2005/2006 Fundamentos de Computadores 14
Ecuación clásica del TCPU -Dependencias
XXAlgoritmo
XTecnología
XXEstructura del computador
XXXISA
XXCompilador
XXLenguaje de programación
TcCPImedio#instrucciones
CCPU TCPINT ××=
Curso 2005/2006 Fundamentos de Computadores 15
Ecuación clásica del TCPU –Autoevaluación I
• Considere dos máquinas A y B con idénticas arquitecturas del repertorio de instrucciones:– A tiene Tc = 1ns y CPI = 2 para un programa concreto– B tiene Tc = 2ns y CPI de 1.2 para ese programa
• ¿Cuánto más rápida (en %) sería una máquina que la otra?
• ¿Cuánto más lenta (en %) sería una máquina que la otra?
Curso 2005/2006 Fundamentos de Computadores 16
Ecuación clásica del TCPU –Autoevaluación II
• Para una declaración particular de un lenguaje de alto nivel, el diseñador del compilador considera dos secuencias de código diferentes– ¿Cuál ejecutará mayor #
de instrucciones?– ¿Cuál es más rápida?– ¿Cuál es el CPI de cada
secuencia?
3C
2B
1A
CPIInstrucción
114Sec2
212Sec1
Tipo CTipo BTipo A
Curso 2005/2006 Fundamentos de Computadores 17
Ecuación clásica del TCPU –Autoevaluación III
• ¿Cuánto más rápida sería la máquina si una cambio…– del sistema de memoria
reduce el CPIload 2 ciclos?– del sistema de predicción
de saltos reduce el CPIbranch 1ciclo?
– del ISA reduce el # de instrucciones ALU a la mitad
2.2
0.4220%Branch
0.3310%Store
1.0520%Load
0.5150%ALU
ICi×CPIi
CPIiICiOp
Curso 2005/2006 Fundamentos de Computadores 18
Ecuación clásica del TCPU –Autoevaluación IV
• Una aplicación escrita en Java tarda 25s en un procesador. Con la nueva versión del compilador Java el número de instrucciones a ejecutar es reducido en un 40% pero el CPI aumenta en un 1.1%. ¿Cuánto tiempo tardará la aplicación en terminar?
Curso 2005/2006 Fundamentos de Computadores 19
Programas para la evaluación del rendimiento - Benchmarks
• Programas de una carga de trabajo estándar para predecir el rendimiento con una carga de trabajo real
– Programas reales típicos• Compiladores (gcc), tratamiento de texto (TeX), herramientas CAD (SPICE)…
– Núcleos de programas reales (Kernels)• Colección de pequeñas partes intensivas temporalmente de programas reales• Ejemplo: Livermore Loops, Linpack…
– Programas triviales (toy bechmarks)• 10-100 líneas de programa.• Ejemplo: quickshort, puzzle,..
– Programas sintéticos• Programas artificiales para evaluar una determinada característica• Ejemplo: Whetstone (punto flotante), Dhrystone (aplicaciones no numéricas)
• ¿Fiabilidad de resultados?– Mejoras específicas (caso matrix300 de los SPEC89)– Mejoras erróneas (caso Intel)
Curso 2005/2006 Fundamentos de Computadores 20
SPEC Benchmarks
• Standard Perfomance Evaluation Cooperative(desde 1988) – AMD * Apple * ATI * Borland * Dell * HP * IBM * Intel *
Microsoft * NVIDIA * Oracle * SGI * Sun * Symantec…
• Benchmarks para CPU, HPC, aplicaciones gráficas, servidores/clientes java, servidores/clientes de correo, sistemas de ficheros, web…
• htpp://www.spec.org
Curso 2005/2006 Fundamentos de Computadores 21
SPEC’89
• Conjunto pequeño de programas– 4 de aritmética entera y 6 de punto flotante– No hay distinción entre SPECs de aritmética
entera y punto flotante• Media geométrica
– Es independiente de la máquina de referencia– No predice tiempos
( )nprogramaglobal
programa
iSPECSPEC
SPEC
1
medir a máquina la deejecución de Tiempo11/780 VAXun deejecución de Tiempo
∏=
=
Curso 2005/2006 Fundamentos de Computadores 22
SPEC’92 y SPEC’95• SPEC’92
– SpecInt92 (6 programas aritmética entera)– SpecFp92 (14 programas de aritmética en FP)– SPECbase
• Medida obtenida sin hacer uso de los flags del compilador que optimiza el código generado según el programa específico. Los flags específicos llegan a aumentar el rendimiento entre un 15% y un 30%
• VAX 11/780 -> 1 Spec(int/fp)92• SPEC’95
– SpecInt95 (8 programas aritmética entera)– SpecFp95 (10 programas de aritmética en FP)– Los SPECs de cada programa se normalizan respecto a una Sun
SPARCStation 10/40 (la VAX 11/780 ya no es operativa)• SparcStation 10/40 -> 1 Spec(int/fp)95• SparcStation 10/40 -> 41.26 SpecInt92 - 34.35 Specfp92
Curso 2005/2006 Fundamentos de Computadores 23
SPEC’95 - Programas
Benchmark Descriptiongo Artificial intelligence; plays the game of Gom88ksim Motorola 88k chip simulator; runs test programgcc The Gnu C compiler generating SPARC codecompress Compresses and decompresses file in memoryli Lisp interpreterijpeg Graphic compression and decompressionperl Manipulates strings and prime numbers in the special-purpose programming language Perlvortex A database programtomcatv A mesh generation programswim Shallow water model with 513 x 513 gridsu2cor quantum physics; Monte Carlo simulationhydro2d Astrophysics; Hydrodynamic Naiver Stokes equationsmgrid Multigrid solver in 3-D potential fieldapplu Parabolic/elliptic partial differential equationstrub3d Simulates isotropic, homogeneous turbulence in a cubeapsi Solves problems regarding temperature, wind velocity, and distribution of pollutantfpppp Quantum chemistrywave5 Plasma physics; electromagnetic particle simulation
Curso 2005/2006 Fundamentos de Computadores 24
SPEC’95 – Pentium
PentiumClock rate (MHz)
SP
EC
fp
Pentium Pro
2
0
4
6
8
3
1
5
7
9
10
200 25015010050
Clock rate (MHz)
SP
EC
int
2
0
4
6
8
3
1
5
7
9
10
200 25015010050
Pentium
Pentium Pro
Procesador SpecInt95 (mejora) SpecFp95 (mejora) Pentium 100 -> 200 MHz (x2) 1.7 1.4
Pentium Pro 150 -> 200 MHz (x1.33) 1.24 1.18
Curso 2005/2006 Fundamentos de Computadores 25
SPEC CPU2000•
• CINT2000 (Integer Component of SPEC CPU2000)– 12 aplicaciones enteras (11 C, 1 C++)– Cint_rate, Cint_non_rate
• CFP2000 (Floating Point Component of SPEC CPU2000)– 14 aplicaciones FP (6 F77, 4 F90, 4 C)– Cfp_rate, Cfp_non_rate
ejecución de Tiempo 256MB) (300MHz _10Sun Ultra5ejecución Tiempo
=programaSPEC
( )nprogramaglobal iSPECSPEC
1
∏=
Curso 2005/2006 Fundamentos de Computadores 26
SPEC CPU2000 - Programas• CINT2000
– 164.gzip → Compresión de datos– 175.vpr → Circuitos FPGA– 176.gcc → Compilador de C– 181.mcf → Resuelve flujos de red
de mínimo coste– 186.crafty → Programa de ajedrez– 197.parser → Procesamiento de
lenguaje natural– 252.eon → Ray tracing– 253.perlbmk → Perl– 254.gap → Teoría computacional
de grupos– 255.vortex → Base de datos
orientada a objetos– 256.bzip2 → Utilidad de
compresión de datos– 300.twolf → Simulador
• CFP2000– 168.wupwise → Cromodinámica cuántica– 171.swim → Modelo de agua– 172.mgrid → Resuelve campo potencial en
3D mutimalla– 173.applu → Ecuaciones diferenciales
parciales parabólicas/elípticas– 177.mesa → librería gráfica 3D– 178.galgel → Dinámica de fluidos– 179.art → Simulación de redes neuronales– 183.equake → Simulación de elementos
finitos– 187.facerec →Reconocedor de caras– 188.ammp →Química computacional– 189.lucas → Teoría de números: Nº primos– 191.fma3d → simulación de choques
mediante elementos finitos– 200.sixtrack → modelo de acelerador de
partículas– 301.apsi → Meteorología: temperatura, viento
y distribución de la polución
Curso 2005/2006 Fundamentos de Computadores 27
SPEC CINT2000 y CFP2000 para Pentium III y Pentium IV
Curso 2005/2006 Fundamentos de Computadores 28
SPECweb99
• La primera versión de benchmarks para servidores webdata de 1996. Actualizados en 1999 y 2005
• Características– Orientados a medir throughput ( número máximo de conexiones
que puede soportar un sistema servidor web). El sistema debe proporcionar respuesta en un tiempo dado y con un número máximo de errores
– Son benchmarks de entornos multiprocesadores– El programa para realizar las peticiones forma parte del
benchmark– El rendimiento depende en gran medida de las características
del sistema, incluyendo el sistema de discos y la red
Curso 2005/2006 Fundamentos de Computadores 29
SPECweb99 - Sistemas DellPowerEdge
• La frecuencia de reloj no es la característica más importante enservidores web– El 8400 tiene el doble de procesadores lentos que el 6600 y ofrece
mejor rendimiento• La configuración adecuada de los sistemas permite obtener mejor
rendimiento (adición de discos e incremento de la conectividad hasta que el procesador sea el cuello de botella)
67002.00848Pentium 4 Xeon MP6600
80010.70887Pentium III Xeon8450/700
42000.70445Pentium III6400/700
46152.204210Pentium 4 Xeon4600
56983.06425Pentium 4 Xeon2650
14541.26121Pentium III2550
34351.13428Pentium III2500
18101.40123Pentium III1650
27651.00222Pentium III1550/1000
Resultadof (GHz)Nº redesNº CPUsNº discosProcesadorSistema
Curso 2005/2006 Fundamentos de Computadores 30
Benchmarks para embeddedcomputing systems
• Un sistema empotrado es un sistema informático de uso específicoconstruido dentro de un dispositivo mayor
• Las aplicaciones dispares de los sistemas empotrados (tiempo real restringido, tiempo real flexible, coste/rendimiento…) dificultan el diseño de benchmarks
• Los benchmarks están en un estado primitivo. Los fabricantes tienen preferencias de benchmarks diferentes (kernels como Dhrystone)
• EDN Embedded Microprocessor Benchmark Consortium (EEMBC)– 34 benchmarks divididos en 5 clases: automoción/industrial, consumo,
networking, automatización de oficinas, telecomunicaciones– Mejor conjunto de benchmarks estandarizados en el entorno embedded– Permite a los fabricantes dar resultados tanto para versiones
modificadas del código fuente como para versiones codificadas a mano de las aplicaciones (los kernels pequeños posibilitan la tarea.
Curso 2005/2006 Fundamentos de Computadores 31
Fiabilidad de los programas de prueba
• El fabricante mejorar el rendimiento con optimizaciones específicas de los benchmarks (los programas reales no mejoran en factores similares)
• Generalmente, los benchmarks reducidos y los sintéticos– No cargan la memoria principal del sistema de forma realista– No calculan nada útil para un usuario (existen excepciones)– No reflejan el comportamiento de ningún programa
• Los benchmarks reales son difíciles de realizar, situación que se agudiza en los casos de:– Máquinas no construidas, simuladores más lentos– Benchmarks no portables– Compiladores no disponibles
Curso 2005/2006 Fundamentos de Computadores 32
Más métricas del rendimiento –MIPS (1/3)
• MIPS (millones de instrucciones por segundo)
• MIPS de pico– MIPS obtenidos con un programa de CPI mínimo (el
programa podría ser inútil)– Dan una idea del rendimiento teórico máximo de la
máquina.– Algunos fabricantes la utilizan a veces en la
publicidad de los productos
106x CPIreloj del Frecuencia
=MIPS Nativos
106x Ejecuciónde TiemponesInstruccio de Recuento
=MIPS Nativos
Curso 2005/2006 Fundamentos de Computadores 33
Más métricas de rendimiento –MIPS (2/3)
• MIPS relativos– MIPS obtenidos respecto a una máquina de referencia
– Proporcionales al tiempo de ejecución SÓLO para un programa dado con una entrada dada
– A medida que pasan los años la máquina de referencia deja de estar operativa
– ¿Debería el computador de referencia ser actualizado con una nueva versión de sistema operativo y compilador?
MIPSTiempoTiempo
MIPS ferencia
maquinalaEn
ferencialativos x Re
__
ReRe =
referenciadecomputadorelparaMIPSMIPSmediramáquinalaenprogramamismodelejecucióndeTiempoTiempo
referenciademáquinalaenprogramaundeejecucióndeTiempoTiempo
ferencia
máquinalaEn
ferencia
==
=
Re
__
Re
Curso 2005/2006 Fundamentos de Computadores 34
Más métricas de rendimiento –MIPS (3/3)
• Inconvenientes de la métrica MIPS:– Los MIPS dependen del # de instrucciones
ejecutadas y por tanto del repertorio de instrucciones– Los MIPS no posibilitan comparar distintas
arquitecturas– Los MIPS varían entre programas en el mismo
computador (no es una medida absoluta por máquina)
– Los MIPS no tienen en cuenta los tres factores de la ecuación de tiempo de CPU (sólo dos de ellos)
– Es posible una variación de los MIPS inversamente proporcional al rendimiento
Curso 2005/2006 Fundamentos de Computadores 35
Más métricas de rendimiento –MFLOPS
• MFLOPS (Millones de operaciones en coma flotante por segundo)
• Inconvenientes– Depende del programa y SÓLO es aplicable a las operaciones en coma
flotante– Instrucciones en coma flotante no comparables entre diferentes
máquinasMáquina A: +, -, * y / Máquina B: No tiene “/” (dará mas MFLOPS)
– Depende de la mezcla de operaciones coma flotante rápidas y lentas• Los MFLOPS para 100 sumas serán mayores que para 100 divisiones
• MFLOPS normalizados– +, -, * y comparaciones: peso 1 OP– / y raíz cuadrada: peso 4 OP– Exponencial y trigonométricas: 8 OP
106x ejecución de Tiempoflotante puntoen soperacione Nº
=MFLOPS
Curso 2005/2006 Fundamentos de Computadores 36
Métodos de comparación y resumen de los resultados
trabajode carga la de programas de Nº niésimo programa delejecución de Tiempo Ti ==
))MFLOPS, (ej. frecuencia una como expresa se orendimient el (Si
i
1
1
1 donde 1
1armónica Mediaaritmética Media
TV
V
nTn
T in
i i
n
iiMedio ==
∑∑
=
=
1.a igual pesos los de Suma iésimo.programa del FrecuenciaiPeso
i
n
iiMedio TPesoT
ponderadaaritméticaMedia
=
=∑= *
1
n. de total un de iésimoprograma elpara ,referencia demáquina la para onormalizad ejecución, de TiempooNormalizad
iT
nn
i
oNormalizadiMedion
i i
i
TT
VPeso
osnormalizadtiempospara geométricaMedia ponderadaarmónica Media
=
=
=
∏∑
=1
1
1
Curso 2005/2006 Fundamentos de Computadores 37
Ley de Amdahl (o ley de rendimientos decrecientes)
• El posible aumento de rendimiento para una mejora dada está limitado por la cantidad que se utiliza la característica mejorada
• Si suponemos que la mejora acelera una fracción F de la tarea en un factor de S, entonces la ganancia de velocidad (speedup) vendrá dada por:
• Corolario: Procurar hacer rápido el caso común
mejorala por afectado no ejecución de Tiempomejorala de Cantidad
mejorala por afectado ejecución de Tiempomejorala de después ejecución de Tiempo
mejorala de después ejecución de Tiempomejorala de antes ejecución de Tiempo
mejorala de antes oRendimientmejorala de después oRendimientvelocidadGanancia
+=
=
==
)1(SF
1 G F−+
= F 1-F1
Curso 2005/2006 Fundamentos de Computadores 38
Ley de Amdahl – Ejemplos (1/3)• Calcula la ganancia de rendimiento obtenida
con la modificación de la unidad de control de un procesador si el tiempo de ejecución de la tarea disminuye de 2,8s a 1,9s
• La ejecución de un programa tarda en una máquina 100s, de los cuales 80 corresponden a instrucciones de multiplicar– ¿Cuánto hay que mejorar la velocidad de la
multiplicación para que mi programa sea cuatro veces más rápido?
– ¿Y para que sea cinco veces más rápido?
Curso 2005/2006 Fundamentos de Computadores 39
Ley de Amdahl – Ejemplos (2/3)• Una propuesta de mejora de un computador implica que
el precio del computador sea el doble. Si el procesador está activo durante el 60% del tiempo de ejecución total de la tarea y la mejora supone aumentar la velocidad del procesador al triple, averigua el interés de introducir la mejora usando para ello la relación precio/ganancia de rendimiento
• La adquisición de un nuevo modelo de computador supone un incremento en la ganancia de rendimiento del 50% respecto al antiguo. Teniendo en cuenta que el antiguo tardaba en ejecutar una tarea 22 segundos, ¿cuánto tiempo empleará el nuevo en ejecutar la misma tarea?
Curso 2005/2006 Fundamentos de Computadores 40
Ley de Amdahl – Ejemplos (3/3)• Suponga paralela un 90% o lo que es lo mismo, una tarea que
puede ejecutarse por varios procesadores simultáneamente, calcula la mejora cuando P = 10, 100 y 100
• Calcula la mejora (para P = 100), si mejoramos en una cantidad 2 la parte no paralela
• Calcula la mejora si a continuación aumentamos la fracción paralelizable en 0.05?
P
SpeedupP 9.01.0
1
+=
3.5
109.01.0
110 =
+=Speedup 17.9
1009.01.0
1100 =
+=Speedup 91.9
10009.01.0
11000 =
+=Speedup
95.16
1009.0
21.0
12,100 =
+=Speedup
80.16
10095.005.0
1100 =
+=Speedup
Curso 2005/2006 Fundamentos de Computadores 41
Rendimiento, potencia y eficiencia de energía
• Los sistemas empotrados y portátiles están limitados por el consumo de potencia (además de por el coste y rendimiento)– Utilizan enfriamiento pasivo (ventiladores versus
tubos de calor) y alimentación con baterías (la duración de las baterías no ha aumentado)
• Técnicas de ahorro de potencia– Desconexión de las partes no utilizadas– Reducción estática o dinámica de la
frecuencia de reloj y el voltaje
Curso 2005/2006 Fundamentos de Computadores 42
Rendimiento, potencia y eficiencia de energía – Familia Pentium (1/2)
• Intel Mobile Pentium y Serie Pentium M
– Procesadores diseñados para aplicaciones móviles alimentadas por baterías
– Tienen una frecuencia máxima (máximo rendimiento) y una frecuencia reducida (mayor vida de la batería)
– Rendimiento/potencia optimizados mediante cambios dinámicos de frecuencia
• El Pentium M tiene mejor rendimiento a fmáxima y a fadaptativa
• El Pentium M a fmínima es más lento que el Pentium 4-M y más rápido que el Pentium III-M
Curso 2005/2006 Fundamentos de Computadores 43
Rendimiento, potencia y eficiencia de energía – Familia Pentium (2/2)
• La eficiencia energética mide la relación entre rendimiento y consumo medio de potencia de entornos con limitaciones de potencia
• Los Pentium M (diseño específico) tienen mayor eficiencia energética que las versiones mobile de Pentium III y Pentium IV (rediseño)
Curso 2005/2006 Fundamentos de Computadores 44
Conclusiones• El arte del diseño consiste en encontrar el equilibrio
entre coste y rendimiento• El TIEMPO es la medida del rendimiento de un
computador
• Imprescindible usar buenos benchmarks para medir el rendimiento de forma fiable...No excesiva credibilidad...
• Las medidas “populares” del rendimiento no reflejan siempre la realidad, a veces son utilizadas malintencionadamente para inducir a error
• Ley de Amdahl establece que la ganancia de rapidez está limitada por la parte del programa que no mejora
cicloCPU TCPINT ××=
Prácticas de Fundamentos de Computadores
Ingeniería Informática
Facultad de Informática
Universidad de Las Palmas de Gran Canaria
PRESENTACIÓN
Las prácticas de laboratorio de esta asignatura se centran en el conocimiento y uso de la arquitectura del R2000 a través de su conjunto de instrucciones. Para ello se han elaborado unas prácticas en las que el alumno utilizará el lenguaje ensamblador de este procesador y conocerá su funcionamiento mediante el simulador SPIM.
Estas prácticas se han diseñado para que el alumno pueda seguirlas de forma casi autónoma, requiriendo únicamente puntuales aclaraciones por parte del profesor. Con ello se pretende que el alumno pueda repasar fuera del horario de prácticas aquellas partes que no hayan quedado lo suficientemente claras.
Las prácticas se han dividido en las siguientes partes:
• Parte 1: El simulador SPIM
Introducción. Descripción del simulador PCSpim Sintaxis del Lenguaje ensamblador del MIPS R2000. Problema propuesto.
• Parte 2: Los datos en memoria
Introducción. Declaración de palabras en memoria. Declaración de bytes en memoria. Declaración de cadenas de caracteres. Reserva de espacio en memoria. Alineación de datos en memoria. Problemas propuestos.
• Parte 3: Carga y almacenamiento de los datos
Introducción. Carga de datos inmediatos (constantes). Carga de palabras (transferencia de palabras desde memoria a registros). Carga de bytes (transferencia de bytes desde memoria a registros). Almacenamiento de palabras (transferencia de palabras desde registros a memoria).
Almacenamiento de bytes (transferencia de bytes desde registros a memoria). Problemas propuestos.
• Parte 4: Las operaciones aritméticas y lógicas
Introducción. Operaciones aritméticas con datos inmediatos (constantes). Operaciones aritméticas con datos en memoria . Operaciones lógicas. Operaciones de desplazamiento. Problemas propuestos.
• Parte 5: Interfaz con el programa
Introducción. Impresión de una cadena de caracteres. Impresión de enteros. Lectura de enteros. Lectura de una cadena de caracteres. Problemas propuestos.
• Parte 6: Estructuras de control: condicionales y bucles
Introducción. Estructura de control condicional Si-entonces con condición simple. Estructura de control condicional Si-entonces con condición compuesta. Estructura de control condicional Si-entonces-sino con condición simple. Estructura de control condicional Si-entonces-sino con condición compuesta. Estructura de control repetitiva para. Estructura de control repetitiva mientras. Problemas propuestos.
• Parte 7: Gestión de subrutinas
Introducción. Gestión de la pila. Llamada y retorno de una subrutina. Llamadas anidadas de subrutinas. Paso de parámetros. Bloque de activación de una subrutina. Problemas propuestos.
Cada una de estas partes no se corresponde con una sesión de prácticas. Así, salvo la primera sesión que será más guiada, en el resto de sesiones el alumno o equipo de alumnos seguirá un ritmo de aprendizaje propio, teniendo en cuenta que deberá haber cubierto todas las partes de estas prácticas en 7 sesiones de 2 horas.
Desde este enlace puedes descargar el simulador que se va a utilizar (SPIM) para Windows:
o Ejecutable SPIM para Windows (comprimido .zip)
El simulador SPIM-->
Parte I. El simulador SPIM
• Introducción. • Descripción del simulador PCSpim. • Sintaxis del Lenguaje ensamblador del MIPS R2000. • Problema propuesto.
Introducción
El SPIM (MIPS al revés) es un simulador que ejecuta programas en lenguaje ensamblador para los computadores basados en los procesadores MIPS R2000/R3000. La arquitectura de este tipo de procesadores es RISC, por lo tanto simple y regular, y en consecuencia fácil de aprender y entender.
La pregunta obvia en estos casos es por qué se va a utilizar un simulador y no una máquina real. Las razones son diversas: entre ellas cabe destacar la facilidad de poder trabajar con una versión simplificada y estable del procesador real. Los procesadores actuales ejecutan varias instrucciones al mismo tiempo y en muchos casos de forma desordenada, esto hace que sean más difíciles de comprender y programar.
El simulador a utilizar en prácticas es una versión gráfica del SPIM, denominadaPCSPIM.
La instalación del PCSpim es sencilla:
Windows
Ejecutar el programa “spimwin.exe”. Se realizará la instalación y sólo habrá que ejecutar el icono “PCSpim for Windows” para arrancar el programa.
Descripción del Simulador PCSpim
Al ejecutar PCSpim aparece la siguiente ventana
La ventana principal de PCSpim se divide en cuatro partes:
1. La parte superior de la ventana es la barra de menús. Permite acceder a las operaciones con ficheros (menú File), especificar las opciones del simulador (menú Simulator), seleccionar la forma de visualización de las ventanas incluidas en la ventana principal (menú Window), y obtener información de ayuda (menú Help).
2. Debajo de la barra de menús se encuentra la barra de herramientas que incluye en forma de botones algunas de las acciones más comunes en PCSpim.
3. La parte central de la ventana de la aplicación sirve para visualizar cuatro ventanas: Registros (Registers), Segmento de Texto (Text Segment), Segmento de Datos (Data Segment) y Mensajes (Messages).
A continuación se presentan las características de estas cuatro ventanas:
• Registros (Registers)
Aparecen el nombre y el contenido de los registros enteros, R0 a R31, con sus correspondientes alias entre paréntesis, los registros de coma flotante, FP0 a FP31, los registros de control de la CPU (BadVAddr, Cause, Status, EPC) y los registros especiales para la multiplicación y división entera, HI y LO.
• Segmento de Texto (Text Segment)
Se pueden ver cada una de las direcciones, el código máquina, las instrucciones ensambladas y el código fuente del programa de usuario (a partir de la dirección 0x00400000) y del núcleo del simulador (a partir de la dirección 0x80000000). Antes de que se cargue ningún programa aparecen una serie de instrucciones, introducidas por el simulador para lanzar adecuadamente la ejecución de nuestro código.
• Segmento de Datos (Data Segment)
Aparecen las direcciones y datos almacenados en las zonas de memoria de datos del usuario (a partir de la dirección 0x10000000 en adelante), el núcleo del simulador (a partir de la dirección 0x90000000) y la pila (el puntero de pila, registro sp, se encuentra cargado con la dirección 0x7fffeffc, y ésta crece hacia direcciones decrecientes).
• Mensajes (Messages)
En este panel se observan los diversos mensajes que comunica el simulador, que nos tendrán informados del resultado y evolución de las acciones que éste lleva a cabo.
Existe una quinta ventana, llamada Consola, independiente, a la que se accede con la opción Window->Console, y que sirve para realizar la entrada/salida del programa simulado. En esta ventana se teclean los datos de entrada, cuando sean necesarios, y se lee la información que pueda imprimir nuestro programa.
Carga y ejecución de programas
Los ficheros de entrada a PCSpim son de tipo texto ASCII, que incluyen las instrucciones ensamblador del programa que se desea simular.
Para cargar un programa se selecciona File->Open (o el botón Open de la barra de herramientas, con el icono de la carpeta abriéndose) con lo que aparecerá un cuadro de diálogo donde se puede seleccionar el fichero que se quiere abrir.
Para ejecutar el programa, Simulator->Go (o el botón Go de la barra de herramientas, con el icono de un programa con una flecha que indica ejecución), hará que PCSpim comience a simularlo. Previamente pedirá que se le indique la dirección de comienzo del programa (en hexadecimal). En nuestro caso este valor será normalmente 0x00400000 (donde comienza nuestro segmento de texto). Si se desea detener la ejecución del programa, Simulator->Break (Ctrl-C). Para continuar con la ejecución, Simulator->Continue.
Si el programa incluye operaciones de lectura o escritura desde el terminal, PCSpim despliega una ventana independiente llamada Console, a través de la cual se realiza la entrada-salida (se simula un terminal de la máquina MIPS).
Depuración de programas
Si un programa no hace lo que se esperaba, hay algunas características del simulador que ayudarán a depurar el programa. Con Simulator->Single Step (o bien la tecla F10) es posible ejecutar las instrucciones del programa una a una (paso a paso). Esto permite verificar el contenido de los registros, la pila, los datos, etc., tras la ejecución de cada instrucción. Empleando Simulator->Multiple Step se consigue ejecutar el programa un número determinado de instrucciones.
PCSpim también permite ejecutar todas las instrucciones de un programa hasta llegar a un determinado punto, denominado breakpoint (punto de ruptura), a partir del cual se puede recuperar el control del programa y, por ejemplo, continuar paso a paso. Para ello, se selecciona Simulator->Breakpoints (o el botón Breakpoints de la barra de herramientas, con el icono de una mano indicando detención). Una vez seleccionada esa opción, PCSpim muestra una ventana en la que pide la(s) dirección(es) en la(s) que se quiere que el programa se detenga, para recuperar el control sobre el mismo. Se debe mirar cuál es la dirección en que interesa parar el programa, en la ventana del segmento de texto, e introducirla (en hexadecimal) en la ventana, pulsando a continuación la tecla ‘Add’, para añadir dicho breakpoint. Se pueden introducir tantos puntos de ruptura como se desee.
Una vez encontrado el error y corregido, se vuelve a cargar el programa con Simulator->Reload<nombre_fichero>. Con Simulator->Clear Registers se pone el contenido de los registros a cero (excepto $sp), mientras que Simulator->Set Value permite cambiar el valor actual de un registro o de una posición de memoria por un valor arbitrario.
Otras opciones útiles disponibles en el menú principal son las contenidas en el menú de ventana (Window). Con ellas se pueden mostrar y ocultar las barras de herramientas y de estado, así como las distintas ventanas del simulador, organizar visualmente las mismas y limpiar la consola de entrada/salida.
PCSpim también proporciona ayuda en línea (Opción Help->Help Topics), que muestra un documento con ayuda sobre el programa, y el icono de la barra de herramientas con una flecha y una interrogación, que sirve para pedir ayuda sobre una opción concreta de los menús.
Opciones del simulador
Al elegir la opción Simulator->Settings se muestran las diversas opciones que ofrece el simulador. PCSpim utiliza estas opciones para determinar cómo cargar y ejecutar los programas. Una vez escogida esta opción aparece la siguiente ventana
El significado de las opciones es el siguiente:
1. Save window positions. PCSpim guarda la posición de las ventanas al salir, y la recupera al ejecutar de nuevo PCSpim.
2. General registers/Floating point registers in hexadecimal. Fija el formato de los registros en hexadecimal. En caso de no estar seleccionada esta opción, se muestra el contenido en decimal (con signo; es decir, interpretado en complemento a 2).
3. Bare machine. Simula el ensamblador sin pseudoinstrucciones o modos de direccionamiento suministrados por el simulador.
4. Allow pseudo instructions. Determina si se admiten las pseudoinstrucciones. 5. Load trap file. Indica si se debe cargar el manejador de interrupciones (fichero
‘trap.handler’). En tal caso, cuando se produce una excepción, PCSpim salta a la dirección 0x80000080, que contiene el código necesario para tratar la excepción.
6. Mapped I/O. Si se selecciona esta opción, se activa la entrada-salida mapeada en Memoria. Los programas que utilizan llamadas al sistema (syscall), para leer o escribir en el terminal, deben desactivar esta opción. Aquellos otros programas que vayan a hacer entrada-salida mediante mapeo en memoria deben tenerla activada.
7. Quiet. Si se activa, PCSpim no imprime mensaje alguno cuando se producen las excepciones. De otra manera, se muestra un mensaje cuando ocurre una excepción.
Sintaxis del Lenguaje ensamblador del MIPS R2000
La sintaxis del lenguaje ensamblador es algo que se descubrirá poco a poco, pero es interesante introducir algunos conceptos básicos:
Comentarios
Estos son muy importantes en los lenguajes de bajo nivel ya que ayudan a seguir el desarrollo del programa y, por tanto, se usan con profusión. Comienzan con un carácter de almohadilla “#” y desde este carácter hasta el final de la línea es ignorado por el ensamblador.
Identificadores
Son secuencias de caracteres alfanuméricos, guiones bajos (_) y puntos (.), que no comienzan con un número. Los códigos de operación son palabras reservadas que no pueden ser utilizadas como identificadores.
Etiquetas
Son identificadores que se sitúan al principio de una línea y seguidos de dos puntos. Sirven para hacer referencia a la posición o dirección de memoria del elemento definido en ésta. A lo largo del programa se puede hacer referencia a ellas en los modos de direccionamiento de las instrucciones.
Pseudoinstrucciones
No son instrucciones que tengan su traducción directa al lenguaje máquina que entiende el procesador, pero el ensamblador las interpreta y las convierte en una o más instrucciones máquina reales. Permiten una programación más clara y comprensible. A lo largo del desarrollo de las prácticas se irán introduciendo diferentes pseudoinstrucciones que permite utilizar este ensamblador.
Directivas
Tampoco son instrucciones que tengan su traducción directa al lenguaje máquina que entiende el procesador, pero el ensamblador las interpreta y le informan a éste de cómo tiene que traducir el programa. Son identificadores reservados, que el ensamblador reconoce y que van precedidos por un punto. A lo largo del desarrollo de las prácticas se irán introduciendo las distintas directivas que permite utilizar este ensamblador.
Por otro lado, los números se escriben, por defecto, en base 10. Si van precedidos de 0x, se interpretan en hexadecimal. Las cadenas de caracteres se encierran entre comillas
dobles (“). Los caracteres especiales en las cadenas siguen la convención del lenguaje de programación C:
• Salto de línea: \n • Tabulador: \t • Comilla: \”
A la hora de generar un fichero con un programa en ensamblador (extensión .s), hay que tener en cuenta que algunas versiones del SPIM tienen un “bug”, que se evita haciendo que los códigos en ensamblador almacenados en estos ficheros terminen siempre con una línea en blanco (vacía).
Problema propuesto
Dado el siguiente ejemplo de programa ensamblador:
.data dato: .byte 3 # inicializo una posición de memoria a 3 .text .globl main # debe ser global main: lw $t0, dato($0)
Indica las etiquetas, directivas y comentarios que aparecen en el mismo.
<--Presentación Los datos en memoria-->
Parte II. Los datos en memoria
• Introducción. • Declaración de palabras en memoria. • Declaración de bytes en memoria. • Declaración de cadenas de caracteres. • Reserva de espacio en memoria. • Alineación de datos en memoria. • Problemas propuestos.
Introducción
Se comienza viendo cómo se definen los datos en memoria. Para ello hay que recordar que, aunque la unidad base de direccionamiento es el byte, las memorias de estos computadores tienen un ancho de 4 bytes o 32 bits, que se llamará palabra o word, el mismo ancho que el del bus de datos. Así pues, cualquier acceso a una palabra de memoria supondrá leer cuatro bytes (el byte con la dirección especificada y los tres almacenados en las siguientes posiciones). Las direcciones de palabra deben estar alineadas en posiciones múltiplos de cuatro.
Otra posible unidad de acceso a memoria es transferir media palabra (half-word).
El ensamblador permite reservar posiciones de memoria para los datos de un programa de usuario, así como inicializar los contenidos de esas direcciones utilizando directivas. En este apartado se describen y crean programas en ensamblador para utilizar estas directivas.
Declaración de palabras en memoria
Utilización de las directivas .data y .word valor
Primer ejercicio
En el directorio de trabajo crea un fichero con la extensión ‘.s’, por ejemplo "ejer1.s", y con el siguiente contenido:
.data # comienza zona de datos palabra1: .word 15 # decimal palabra2: .word 0x15 # hexadecimal
Este programa en ensamblador incluye diversos elementos que se describen a continuación: la directiva .data dir indica que los elementos que se definen a continuación se almacenarán en la zona de datos y, al no aparecer ninguna dirección como argumento de dicha directiva, la dirección de almacenamiento será la que hay por defecto (0x10010000). Las dos sentencias que aparecen a continuación reservan dos números enteros, de tamaño word, en dos direcciones de memoria, una a continuación de la otra, con los contenidos especificados.
Ejecuta el programa ‘xspim’ desde el directorio de trabajo y cárgalo con la opción File->Open...
Cuestiones
• Encuentra los datos almacenados por el programa anterior en memoria. Localiza dichos datos en el panel de datos e indica su valor en hexadecimal.
• ¿En qué direcciones se han almacenado dichos datos? ¿Por qué? • ¿Qué valores toman las etiquetas palabra1 y palabra2?
Segundo ejercicio
Crea otro fichero (ejer2.s) o modifica el anterior con el siguiente código:
.data 0x10010000 # comienza zona de datos palabras: .word 15,0x15 # decimal/hexadecimal
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• Comprueba si hay diferencias respecto al programa anterior. • Crea un fichero con un código que defina un vector de cinco palabras (word),
que esté asociado a la etiqueta “vector”, que comience en la dirección 0x10000000 y con los valores 0x10, 30, 0x34, 0x20 y 60. Comprueba que se almacena de forma correcta en memoria.
• ¿Qué ocurre si se quiere que el vector comience en la dirección 0x10000002? ¿En qué dirección comienza realmente? ¿Por qué?
Declaración de bytes en memoria
La directiva .byte valor inicializa una posición de memoria, de tamaño byte, a valor.
Tercer ejercicio
Crea un fichero con el siguiente código:
.data # comienza zona de datos octeto: .byte 0x10 # hexadecimal
Borra los valores de la memoria Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• ¿Qué dirección de memoria se ha inicializado con el contenido especificado? • ¿Qué valor se almacena en la palabra que contiene el byte?
Cuarto ejercicio
Crea otro fichero o modifica el anterior con el siguiente código:
.data # comienza zona de datos palabra1: .byte 0x10,0x20,0x30,0x40 # hexadecimal palabra2: .word 0x10203040 # hexadecimal
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• ¿Cuáles son los valores almacenados en memoria? • ¿Qué tipo de alineamiento y organización de los datos (Big-endian o Little-
endian) utiliza el simulador? ¿Por qué? • ¿Qué valores toman las etiquetas palabra1 y palabra2?
Declaración de cadenas de caracteres
La directiva .ascii “tira” permite cargar en posiciones de memoria consecutivas, de tamaño byte, el código ascii de cada uno de los caracteres que componen “tira”.
Quinto ejercicio
Crea un fichero con el siguiente código:
.data cadena: .ascii "abcde" # defino string octeto: .byte 0xff
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• Localiza la cadena anterior en memoria. • ¿Qué ocurre si en vez de .ascii se emplea la directiva .asciiz? Describe lo que
hace esta última directiva. • Crea otro fichero cargando la tira de caracteres “cadena” en memoria utilizando
la directiva .byte.
Reserva de espacio en memoria
La directiva .space n sirve para reservar espacio para una variable en memoria, inicializándola a 0.
Sexto ejercicio
Crea un fichero con el siguiente código:
.data # comienza zona de datos espacio: .space 8 # reservo espacio .byte 0xff
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• ¿Qué rango de posiciones se han reservado en memoria para la variable espacio? • ¿Cuántos bytes se han reservado en total? ¿Y cuántas palabras?
Alineación de datos en memoria
La directiva .align n alinea el siguiente dato a una dirección múltiplo de 2n.
Séptimo ejercicio
Crea un fichero con el siguiente código:
.data # comienza zona de datos byte1: .byte 0x10 espacio: .space 4 byte2: .byte 0x20 palabra: .word 10
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• ¿Qué rango de posiciones se han reservado en memoria para la variable espacio? ¿Estos cuatro bytes podrían constituir los bytes de una palabra? ¿Por qué?
• ¿A partir de que dirección se ha inicializado byte1? ¿y byte2? • ¿A partir de que dirección se ha inicializado palabra? ¿Por qué?
Octavo ejercicio
Crea un fichero con el siguiente código:
.data # comienza zona de datos byte1: .byte 0x10 .align 2 espacio: .space 4 byte2: .byte 0x20 palabra: .word 10
Borra los valores de la memoria con la opción Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
• ¿Qué rango de posiciones se ha reservado en memoria para la variable espacio? ¿Estos cuatro bytes podrían constituir los bytes de una palabra? ¿Por qué?
• ¿Qué ha hecho la directiva .align?
Problemas propuestos
1. Diseña un programa ensamblador que reserva espacio para dos vectores A y B de 20 palabras cada uno a partir de la dirección 0x10000000.
2. Diseña un programa ensamblador que realice la siguiente reserva de espacio en memoria a partir de la dirección 0x10001000:
o una palabra o un byte o una palabra alineada en una dirección múltiplo de 4.
3. Diseña un programa ensamblador que realice la siguiente reserva de espacio e inicialización en memoria a partir de la dirección por defecto: 3 (palabra), 0x10 (byte), reserve 4 bytes a partir de una dirección múltiplo de 4, y 20 (byte).
4. Diseña un programa ensamblador que defina, en el espacio de datos, la siguiente cadena de caracteres: “Esto es un problema” utilizando
o .ascii o .byte o .word
5. Sabiendo que un entero se almacena en un word, diseña un programa ensamblador que defina en la memoria de datos la matriz A de enteros definida como
a partir de la dirección 0x10010000 suponiendo que:
o La matriz A se almacena por filas. o La matriz A se almacena por columnas.
<--El simulador SPIM Carga y almacenamiento de los datos-->
Parte III. Carga y almacenamiento de los datos
• Introducción. • Carga de datos inmediatos (constantes). • Carga de palabras (transferencia de palabras desde memoria a registros). • Carga de bytes (transferencia de bytes desde memoria a registros). • Almacenamiento de palabras (transferencia de palabras desde registros a
memoria). • Almacenamiento de bytes (transferencia de bytes desde registros a memoria). • Problemas propuestos.
Introducción
En esta tercera parte se estudia cómo cargar los datos en los registros del R2000 (empleando los registros generales del procesador) y almacenar después su valor en memoria. Dado que la arquitectura del R2000 es RISC, utiliza un subconjunto concreto de instrucciones que permiten las acciones de carga y almacenamiento de los datos entre los registros del procesador y la memoria. Generalmente, las instrucciones de carga de un dato de memoria a registro comienzan con la letra “l” (de load en inglés) y las de almacenamiento de registro en memoria con “s” (de store en inglés), seguidos por la letra inicial correspondiente al tamaño de dato que se va a mover (en inglés), b para byte, h para media palabra y w para palabra.
Carga de datos inmediatos (constantes)
Primer ejercicio
Crea un fichero con el siguiente código:
.text # zona de instrucciones main: lui $s0, 0x8690
La directiva .text sirve para indicar el comienzo de la zona de memoria dedicada a las instrucciones. Por defecto esta zona comienza en la dirección 0x00400000 y en ella, se pueden ver las instrucciones que ha introducido el simulador para
ejecutar, de forma adecuada, nuestro programa. La primera instrucción de nuestro programa debe estar referenciada con la etiqueta main:. Esta etiqueta le indica al simulador dónde está el principio del programa que debe ejecutar. Por defecto hace referencia a la dirección 0x00400020. A partir de esta dirección, el simulador cargará el código de nuestro programa en el segmento de memoria de instrucciones.
La instrucción lui es la única instrucción de carga inmediata real, y almacena la media palabra que indica el dato inmediato de 16 bits en la parte alta del registro especificado, en este caso s0. La parte baja del registro se pone a 0.
Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize y carga el nuevo fichero.
Cuestiones
Localiza la instrucción en memoria de instrucciones e indica:
La dirección donde se encuentra.
El tamaño que ocupa.
La instrucción máquina, analizando cada campo de ésta e indicando que tipo de formato tiene.
Ejecuta el programa con la opción del menú principal Simulator->Go . Comprueba el efecto de la ejecución del programa en el registro.
Segundo ejercicio
El ensamblador del MIPS ofrece la posibilidad de cargar una constante de 32 bits en un registro utilizando una pseudoinstrucción. Ésta es la pseudoinstrucción li.
Crea un fichero con el siguiente código:
.text # zona de instrucciones main: li $s0, 0x12345678 Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize , carga el nuevo fichero y ejecútalo con la opción del menú principal Simulator->Go
Cuestiones
Comprueba el efecto de la ejecución del programa en el registro.
Comprueba qué conjunto de instrucciones reales implementan esta pseudoinstrucción.
Carga de palabras (transferencia de palabras desde memoria a registros)
Tercer ejercicio
Crea un fichero con el siguiente código:
.data palabra: .word 0x10203040 .text # zona de instrucciones main: lw $s0, palabra($0)
La instrucción "lw" carga la palabra contenida en una posición de memoria, cuya dirección se especifica en la instrucción, en un registro. Dicha posición de memoria se obtiene sumando el contenido del registro (en este caso $0, que siempre vale cero) y el identificador "palabra".
Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize, carga el nuevo fichero y ejecútalo con la opción del menú principal Simulator->Go
Cuestiones
Localiza la instrucción en memoria de instrucciones e indica cómo ha transformado dicha instrucción el simulador.
Explica cómo se obtiene a partir de esas dos instrucciones la dirección de “palabra”. ¿Por qué crees que el simulador traduce de esta forma la instrucción original?
Analiza cada uno de los campos que componen estas instrucciones e indica el tipo de formato que tienen.
Comprueba el efecto de la ejecución del programa.
¿Qué pseudoinstrucción permite cargar la dirección de un dato en un registro? Modifica el programa original para que utilice esta pseudoinstrucción, de forma que el programa haga la misma tarea. Comprueba qué conjunto de instrucciones sustituyen a la pseudoinstrucción utilizada una vez el programa se carga en la memoria del simulador.
Modifica el código para que en lugar de transferir la palabra contenida en la dirección de memoria referenciada por la etiqueta palabra, se intente transferir la palabra que está contenida en la dirección referenciada por palabra+1. Explica qué ocurre y por qué.
Modifica el programa anterior para que guarde en el registro $s0 los dos bytes de mayor peso de "palabra". Nota: Utiliza la instrucción lh que permite cargar medias palabras (16 bits) desde memoria a un registro (en los 16 bits de menor peso del mismo).
Carga de bytes (transferencia de bytes desde memoria a registros)
Cuarto ejercicio
Crea un fichero con el siguiente código:
#------------------------------------------------# # zona de datos # .data #------------------------------------------------# octeto: .byte 0xf3 siguiente: .byte 0x20 #------------------------------------------------# # zona de instrucciones # .text #------------------------------------------------# main: lb $s0, octeto($0)
• La instrucción "lb" carga el byte de una dirección de memoria en un registro. Al igual que antes la dirección del dato se obtiene sumando el contenido del registro $0 (en este caso siempre vale cero) y el identificador "octeto".
Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize, carga el nuevo fichero y ejecútalo con la opción del menú principal Simulator->Go
Cuestiones
Localiza la instrucción en memoria de instrucciones e indica cómo ha transformado dicha instrucción el simulador.
Comprueba el efecto de la ejecución del programa.
Cambia en el programa la instrucción "lb" por "lbu". ¿Qué sucede al ejecutar el programa? ¿Qué significa esto?
Si "octeto" se define como:
octeto: .byte 0x30
¿existe diferencia entre el uso de la instrucción lb y lbu ¿ ¿Por qué¿
¿Cuál es el valor del registro s0 si “octeto” se define como:
octeto: .word 0x10203040 ?.
¿Por qué?
¿Cuál es el valor del registro s0 si se cambia en "main" la instrucción existente por la siguiente
main: lb $s0, octeto+1($0)?
¿Por qué? ¿Por qué en este caso no se produce un error de ejecución (excepción de error de direccionamiento)?
Almacenamiento de palabras (transferencia de palabras desde registros a memoria)
Quinto ejercicio
Crea un fichero con el siguiente código:
#------------------------------------------------# # zona de datos # .data #------------------------------------------------# palabra1: .word 0x10203040 palabra2: .space 4 palabra3: .word 0xffffffff #------------------------------------------------# # zona de instrucciones # .text #------------------------------------------------# main: lw $s0, palabra1($0) sw $s0, palabra2($0) sw $s0, palabra3($0)
La instrucción "sw" almacena la palabra contenida en un registro en una dirección de memoria. Esta dirección se obtiene sumando el contenido de un registro más un desplazamiento especificado en la instrucción (identificador).
Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize, carga el nuevo fichero y ejecútalo con la opción del menú principal Simulator->Go
Cuestiones
Localiza la primera instrucción de este tipo en la memoria de instrucciones e indica cómo ha transformado dicha instrucción el simulador.
Comprueba el efecto de la ejecución del programa.
Almacenamiento de bytes (transferencia de bytes desde registros a memoria)
Sexto ejercicio
Crea un fichero con el siguiente código:
#------------------------------------------------# # zona de datos # .data #------------------------------------------------# palabra1: .word 0x10203040 octeto: .space 2 #------------------------------------------------# # zona de instrucciones # .text #------------------------------------------------# main: lw $s0, palabra1($0) sb $s0, octeto($0)
La instrucción “sb” almacena el byte de menor peso de un registro en una dirección de memoria. La dirección se obtiene sumando el desplazamiento indicado por el identificador y el contenido de un registro.
Borra los valores de la memoria con la opción del menú principal Simulator->Reinitialize, carga el nuevo fichero y ejecútalo con la opción del menú principal Simulator->Go
Cuestiones
Localiza la instrucción en memoria de instrucciones e indica cómo ha transformado dicha instrucción el simulador.
Comprueba el efecto de la ejecución del programa.
Modifica el programa para que el byte se almacene en la dirección "octeto+1". Comprueba y describe el resultado de este cambio.
• Modifica el programa anterior para transferir a la dirección de octeto el byte en la posición palabra+3.
Problemas propuestos
Diseña un programa ensamblador que defina el vector de palabras V=(10,20,25,500,3) en la memoria de datos a partir de la dirección 0x10000000 y cargue todos sus componentes en los registros s0-s4.
Diseña un programa ensamblador que copie el vector definido en el problema anterior a partir de la dirección 0x10010000.
Diseña un programa ensamblador que, dada la palabra 0x10203040, almacenada en una posición de memoria, la reorganice en otra posición de memoria, invirtiendo el orden de sus bytes.
Diseña un programa ensamblador que, dada la palabra 0x10203040 definida en memoria la reorganice en la misma posición, intercambiando el orden se sus medias palabras. Nota: utiliza las instrucciones lh y sh.
Diseña un programa en ensamblador que inicialice cuatro bytes a partir de la posición 0x10010002 a los siguientes valores 0x10, 0x20, 0x30, 0x40, y reserve espacio para una palabra a partir de la dirección 0x10010010. El programa transferirá los cuatro bytes contenidos a partir de la posición 0x10010002 a la dirección 0x10010010.
<--Los datos en memoria Las operaciones aritméticas y lógicas>-->
Parte 4. Las operaciones aritméticas y lógicas
• Introducción. • Operaciones aritméticas con datos inmediatos (constantes) . • Operaciones aritméticas con datos en memoria. . • Operaciones lógicas. . • Operaciones de desplazamiento. . • Problemas propuestos.
Introducción
En este apartado se presentan las instrucciones que permiten realizar operaciones aritméticas, lógicas y de desplazamiento. Entre las primeras se encuentran las instrucciones de suma y resta (add, addu, addi, addiu, sub, subu) y las instrucciones de multiplicación y división (mult, multu, div, divu ). Las instrucciones acabadas en u consideran los operandos como números en binario puro, mientras que las instrucciones no acabadas en u consideran los operandos de las instrucciones como números en complemento a dos. En ambos casos, se producirá una excepción aritmética si el resultado de la operación no es representable en 32 bits. Recuerda que el rango de representación de los números enteros con signo de 32 bits en complemento a 2 va desde –2.147.483.648 a 2.147.483.647 (0x80000000 a 0x7fffffff).
Dentro del grupo de instrucciones que permiten realizar operaciones lógicas están: suma lógica (or y ori), producto lógico (and y andi) y la or exclusiva (xor y xori).
Finalmente, se presentan las instrucciones de desplazamiento aritmético y lógico (sra, sll, srl).
Operaciones aritméticas con datos inmediatos (constantes)
Primer ejercicio
.data numero: .word 2147483647 .text main: lw $t0,numero($0) addiu $t1,$t0,1
• La instrucción addiu es una instrucción de suma con un dato inmediato y sin detección de desbordamiento.
Borra los valores de la memoria, carga el fichero y ejecútalo paso a paso.
Cuestiones
• Localiza el resultado de la suma efectuada. Comprueba el resultado. • Cambia la instrucción "addiu" por la instrucción "addi". • Borra los valores de la memoria, carga el fichero y ejecútalo paso a paso. • ¿Qué ha ocurrido al efectuar el cambio? ¿Por qué?
Operaciones aritméticas con datos en memoria
Segundo ejercicio
.data numero1: .word 0x80000000 numero2: .word 1 numero3: .word 1 .text main: lw $t0,numero1($0) lw $t1,numero2($0) subu $t0,$t0,$t1 lw $t1,numero3($0) subu $t0,$t0,$t1 sw $t0,numero3($0)
Borra los valores de la memoria, carga el fichero y ejecútalo paso a paso.
Cuestiones
• ¿Qué hace el programa anterior? ¿Qué resultado se almacena en numero3? ¿Es correcto?
• ¿Se producirá algún cambio si las instrucciones "subu" son sustituidas por instrucciones "sub"? ¿Por qué?
Multiplicación y división con datos en memoria
Tercer ejercicio
Crea un fichero con el siguiente código:
.data numero1: .word 0x7fffffff numero2: .word 16 .space 8 .text main: lw $t0,numero1($0) lw $t1,numero2($0) mult $t0,$t1
mflo $t0 mfhi $t1 sw $t0,numero2+4($0) sw $t1,numero2+8($0)
• La instrucción mult multiplica dos registros de propósito general (en el ejemplo anterior los registros t0 y t1) y deja el resultado de 64 bits en dos registros especiales de 32 bits llamados HI y LO. Las instrucciones mfhi y mflo sirven para mover los contenidos de estos registros especiales a los registros de propósito general (en este caso otra vez los registros t0 y t1). El código realiza la multiplicación de dos números, almacenando el resultado de la multiplicación a continuación de los dos multiplicandos.
Borra los valores de la memoria, carga el fichero y ejecútalo.
Cuestiones
• ¿Qué resultado se obtiene después de realizar la operación? ¿Por qué se almacena en dos palabras de memoria?
• Modifica los datos anteriores para que numero1 y numero2 sean 0xffffffff y 1 respectivamente. ¿Cuál es el valor del registro HI? ¿Por qué?
• La instrucción de tipo R mul multiplica dos registros y guarda el resultado en un tercero. Escribe un programa en ensamblador que utilice la instrucción mul para multiplicar numero1 y número2 y deje el resultado en el registro $t2. ¿Deja el resultado también en algún otro registro?
• ¿Qué ocurre al cambiar la instrucción mul en el programa anterior por la pseudoinstrucción mulo?
• ¿Qué ocurre al cambiar la pseudoinstrucción mulo en el programa anterior por la pseudoinstrucción mulou?
• Modifica los datos anteriores para que numero1 y numero2 sean 10 y 3 respectivamente. Escribe el código que divida numero1 entre numero2 (dividendo y divisor respectivamente) y coloque el cociente y el resto a continuación de dichos números.
• La pseudointrucción div divide dos registros y guarda el resultado en un tercero (de manera similar a cualquier instrucción tipo-R). Escribe un programa en ensamblador que utilice la pseudoinstrucción div para dividir numero1 y número2 y deje el resultado en el registro $t2. ¿Comprueba excepciones? ¿Cuál?
• ¿Qué ocurre al cambiar la pseudoinstrucción div en el programa anterior por la pseudoinstrucción divu? ¿Qué es diferente en el código generado para las pseudoinstrucciones div y divu?
Operaciones lógicas
Cuarto ejercicio
Crea un fichero con el siguiente código:
.data
numero: .word 0x3ff41 .space 4 .text main: lw $t0,numero($0) andi $t1,$t0,0xfffe sw $t1,numero+4($0)
• El código anterior pone a 0 los 16 bits más significativos y el bit 0 de número, almacenando el resultado en la siguiente palabra. Esto se consigue utilizando la instrucción andi, que realiza el producto lógico bit a bit entre el dato contenido en un registro y un dato inmediato. El resultado que se obtiene es: aquellos bits que en el dato inmediato están a 1 no se modifican con respecto al contenido original del registro, es decir, los 16 bits de menor peso excepto el bit 0. Por otro lado, todos aquellos bits que en el dato inmediato están a 0, en el resultado también están a 0, es decir, los 16 bits de mayor peso y el bit 0. Los 16 bits da mayor peso se ponen a 0 puesto que, aunque el dato inmediato que se almacena en la instrucción es de 16 bits, a la hora de realizar la operación el procesador trabaja con un dato de 32 bits, poniendo los 16 de mayor peso a 0, fijando, por tanto, los bits del resultado también a 0.
Borra los valores de la memoria, carga el fichero y ejecútalo.
Cuestiones
• Modifica el código para obtener, en la siguiente palabra, que los 16 bits más significativos de número permanezcan tal cual, y que los 16 bits menos significativos queden a 0, excepto el bit 0 que también debe quedar como estaba. La solución debe ser válida independientemente del valor almacenado en número.
• Modifica el código para obtener, en la siguiente palabra, que los 16 bits más significativos de número permanezcan tal cual, y que los 16 bits menos significativos queden a 1, excepto el bit 0 que también debe quedar como estaba. La solución debe ser válida independientemente del valor almacenado en numero.
Operaciones de desplazamiento
Quinto ejercicio
Crea un fichero con el siguiente código:
.data numero: .word 0xffffff41 .text main: lw $t0,numero($0) sra $t1,$t0,4
• El código desplaza el número cuatro bits a la derecha, rellenando con el bit del signo.
Borra los valores de la memoria, carga el fichero y ejecútalo.
Cuestiones
• ¿Para qué se ha rellenado el número con el bit del signo? • ¿Qué ocurre si se sustituye la instrucción "sra" por "srl"? • Modifica el código para desplazar el número tres bits a la izquierda.
Problemas propuestos
1. Diseña un programa ensamblador que defina el vector de enteros de dos elementos V=(10,20) en la memoria de datos a partir de la dirección 0x10000000 y almacene su suma a partir de la dirección donde acaba el vector.
2. Diseña un programa ensamblador que divida los enteros 18,-1215 almacenados a partir de la dirección 0x10000000 entre el número 5 y que a partir de la dirección 0x10010000 almacene el cociente de dichas divisiones. Es posible usar más de una directiva .data para ubicar las sección de datos.
3. Pon a cero los bits 3,7,9 del entero 0xABCD12BD almacenado en memoria a partir de la dirección 0x10000000, sin modificar el resto.
4. Cambia el valor de los bits 3,7,9 del entero 0xFF0F1235 almacenado en memoria a partir de la dirección 0x10000000, sin modificar el resto.
5. Multiplica el número 0x1237, almacenado en memoria a partir de la dirección 0x10000000, por 32 (25) sin utilizar las instrucciones de multiplicación ni las pseudoinstrucciones de multiplicación.
<--Carga y almacenamiento de datos en memoria
Interfaz con el
programa> --
Parte 5. Interfaz con el programa
• Introducción. • Impresión de una cadena de caracteres. • Impresión de enteros. • Lectura de enteros. • Lectura de cadena de caracteres. • Problemas propuestos.
Introducción
El SPIM ofrece un pequeño conjunto de servicios tipo Sistema Operativo a través de la instrucción de llamada al sistema (syscall). Estos servicios permiten introducir datos y visualizar resultados, de forma cómoda, en los programas que se desarrollan. Para pedir un servicio, el programa debe cargar el número identificador del tipo de llamada al sistema en el registro $v0 y el/los argumento/s en los registros $a0-$a3 (o f12 para valores en coma flotante). Las llamadas al sistema que retornan valores ponen sus resultados en el registro $v0 ($f0 en coma flotante). La interfaz con nuestro programa se hará a través de una ventana o consola que puede visualizarse u ocultarse mediante el botón "terminal". A continuación se muestra una tabla resumen del número de identificación de cada una de las funciones disponibles y de los parámetros que son necesarios en cada una de ellas:
Servicio Número de identificación (en $v0) Argumentos Resultado
Imprimir_entero 1 $a0=entero
Imprimir_cadena 4 $a0=dir_cadena
Leer_entero 5 Entero (en $v0)
Leer_string 8 $a0=dir_cadena,
$a1=longitud
Impresión de una cadena de caracteres
Primer ejercicio
.data dir: .asciiz "Hola. Ha funcionado." .text
main: li $v0,4 #codigo de imprimir cadena la $a0,dir #direccion de la cadena syscall #llamada al sistema
• La pseudoinstrucción "li" carga de forma inmediata el dato que acompaña la instrucción en el registro. La pseudoinstrucción "la" carga de forma inmediata la dirección que acompaña la instrucción en el registro especificado.
Borra los valores de la memoria, carga el fichero y ejecútalo.
Cuestiones
• Comprueba que se imprime la cadena de caracteres "Hola. Ha funcionado." Vuélvelo a ejecutar. Acuérdate que antes de volver a ejecutar el programa se debe borrar el contenido de los registros. ¿Dónde se imprime el mensaje?
• Introduce al final de la cadena los caracteres "\n". Ejecútalo dos veces y comprueba cuál es la diferencia con respecto al código original.
• Modifica la línea de la instrucción "la ..." para que sólo se imprima "Ha funcionado.".
Impresión de enteros.
Segundo ejercicio
Crea un fichero con el siguiente código:
.data dir: .asciiz "Se va a imprimir el entero: " entero: .word 7 .text main: li $v0,4 #codigo de imprimir cadena la $a0,dir #direccion de la cadena syscall #llamada al sistema li $v0,1 #codigo de imprimir entero li $a0,5 #entero a imprimir syscall #llamada al sistema
Borra los valores de la memoria, carga el fichero y ejecútalo.
Cuestiones
• Comprueba la impresión del entero "5". • Modifica el programa para que se imprima el entero almacenado en la dirección
"entero". Comprueba su ejecución.
Lectura de enteros.
Tercer ejercicio
Crea un fichero con el siguiente código:
.data dir: .asciiz "Introduce el entero: " .align 2 entero: .space 4 .text main: li $v0,4 #codigo de imprimir cadena la $a0,dir #direccion de la cadena syscall #llamada al sistema li $v0,5 #codigo de leer entero syscall #llamada al sistema
Borra los valores de la memoria, carga el fichero y ejecútalo. Introduce, a través de la consola, el entero que te parezca.
Cuestiones
• Comprueba el almacenamiento del entero introducido en el registro v0. • Modifica el programa para que el entero leído se almacene en la dirección de
memoria "entero". • Elimina la línea align 2 del programa anterior y ejecútalo. ¿Qué ocurre? ¿Por
qué?
Lectura de cadena de caracteres.
Cuarto ejercicio
Crea un fichero con el siguiente código:
.data dir: .asciiz "Introduce la cadena de caracteres: " buffer: .space 10 .text main: li $v0,4 #codigo de imprimir cadena la $a0,dir #direccion de la cadena syscall #llamada al sistema li $v0,8 #codigo de leer el string la $a0,buffer #direccion de lectura de cadena li $a1,10 #espacio maximo de la cadena
syscall #llamada al sistema
Borra los valores de la memoria, carga el fichero y ejecútalo. Introduce, a través de la consola, la cadena de caracteres que te parezca.
Cuestiones
• Comprueba el almacenamiento de la cadena de caracteres en "buffer". • ¿Qué ocurre si la cadena de caracteres que se escribe es más larga que el tamaño
reservado en "buffer"?
Problemas propuestos
1. Diseña un programa ensamblador que pida por la consola dos enteros "A" y "B" dando como resultado su suma "A+B".
2. Diseña un programa que pida los datos de un usuario por la consola y los introduzca en memoria, reservando espacio para ello. La estructura de la información es la siguiente:
Nombre cadena de 10 bytes
Apellidos cadena de 15 bytes
DNI entero
A continuación se deberá imprimir los datos introducidos para comprobar el correcto funcionamiento del programa.
<--Operaciones aritméticas y lógicas
Estructuras de
control> --
Parte 6. Estructuras de control: condicionales y bucles
• Introducción. • Estructuras de control condicional Si-entonces con condición simple . • Estructuras de control condicional Si-entonces con condición compuesta . • Estructuras de control condicional Si-entonces-sino con condición simple . • Estructuras de control condicional Si-entonces-sino con condición compuesta . • Estructuras de control repetitiva para . • Estructuras de control repetitiva mientras . • Problemas propuestos.
Introducción
El lenguaje ensamblador no dispone de estructuras de control de flujo de programa definidas a priori, que permitan decidir entre dos (o varios) caminos de ejecución de instrucciones distintos (como por ejemplo la sentencia if de otros lenguajes de programación). En esta práctica se describe cómo implementar algunas de estas estructuras de control.
En primer lugar se realiza un breve recordatorio de las instrucciones que dispone el MIPS R2000 a partir de las cuales se llevan a cabo las implementaciones de estructuras de este tipo. Estas se agrupan en tres grupos: instrucciones de ruptura de secuencia condicional e incondicional, e instrucciones de comparación.
Instrucciones de salto condicional
El ensamblador del MIPS incluye dos instrucciones básicas de ruptura de secuencia condicional beq (branch if equal, saltar si igual) y bne (branch if no equal, saltar si distinto). La sintaxis de estas instrucciones es la siguiente:
beq rs, rt, etiqueta bne rs, rt, etiqueta.
Ambas comparan el contenido de los registros rs y rt y saltan a la dirección de la instrucción referenciada por etiqueta si el contenido del registro rs es igual al del rt (beq) o distinto (bne).
Además dispone de instrucciones de salto condicional para realizar comparaciones con cero. Estas instrucciones son: bgez (branch if greater or equal to zero, saltar si mayor o igual a cero), bgtz (branch if greater than zero, saltar si mayor que cero), blez (branch if
less or equal to zero, saltar si menor o igual que cero), bltz (branch if less than zero, saltar si menor que cero), y tienen la siguiente sintaxis:
bgez rs, etiqueta bgtz rs, etiqueta blez rs, etiqueta bltz rs, etiqueta
Todas ellas comparan el contenido del registro rs con 0 y saltan a la ón de la instrucción referenciada por etiqueta si rs >=0 (bgez), rs > 0 (bgtz), rs<=0 (blez) ó rs<0 (bltz).
Instrucciones de salto incondicional
La instrucción j permite romper la secuencia de ejecución del programa de forma incondicional y desviarla hacia la instrucción referenciada mediante la etiqueta. Esta instrucción presenta el siguiente formato:
j etiqueta
Instrucciones de comparación
El ensamblador del MIPS dispone de una instrucción que compara dos registros, y pone un 1 en un tercer registro si el contenido del primero es menor que el segundo y pone un 0 si no se cumple esta condición. Esta instrucción es slt (set if less than, poner a 1 si menor que) y tiene la siguiente sintaxis:
slt rd, rs, rt
A partir de este conjunto de instrucciones se puede implementar cualquier estructura de control de flujo del programa.
Pseudoinstrucciones de salto condicional
Para facilitar la programación, el lenguaje ensamblador del MIPS aporta un conjunto de pseudoinstrucciones de salto condicional que permiten comparar dos variables almacenadas en registros (a nivel de mayor, mayor o igual, menor, menor o igual) y según el resultado de esa comparación saltan o no, a la instrucción referenciada a través de la etiqueta. Estas pseudoinstrucciones son: bge (branch if greater or equal, saltar si mayor o igual ), bgt (branch if greater, saltar si mayor que), ble (branch if less or equal, saltar si menor o igual), blt (branch if less, saltar si menor que). El formato es el mismo para todas ellas:
bxx rs,rt, etiqueta
El salto a la instrucción referenciada por etiqueta se efectúa si el resultado de la comparación entre las variables contenidas en rs y rt es: mayor o igual (ge), mayor (gt), menor o igual (le), o menor (lt). La implementación de estas pseudoinstrucciones se realiza a partir de la instrucción slt y de las instrucciones de salto condicional básicas: beq y bne, principalmente.
Una vez introducidos el conjunto de instrucciones y pseudoinstrucciones que permiten implementar cualquier estructura de control de flujo de programa, se va a describir cómo se implementan las estructuras más típicas de un lenguaje de alto nivel. Estas son: Si-entonces, Si-entonces-sino, Mientras y Para si se habla en lenguaje algorítmico, o las estructuras if-then, if-then-else, while, y for del lenguaje Pascal. De ellas, las dos primeras son estructuras de control de flujo condicionales, y el resto son estructuras de control de flujo repetitivas. Estas estructuras dependen, implícita o explícitamente, de la verificación de una o varias condiciones para determinar el camino que seguirá la ejecución del código en curso. La evaluación de esta condición (o condiciones) vendrá asociada a una o varias instrucciones de salto condicional e incondicional o pseudoinstrucciones.
Estructura de control condicional Si-entonces con condición simple
Primer ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control condicional Si-entonces:
.data dato1: .word 40 dato2: .word 30 res: .space 4 .text main: lw $t0, dato1($0) #cargar dato1 en t0 lw $t1, dato2($0) #cargar dato2 en t1 and $t2, $t2,$0 #pone a 0 t2 add $t3, $t0,$t1 #t3 = t0+t1 Si: beq $t1, $0, finsi #si t1 = 0 finsi entonces: div $t0, $t1 #t0/t1 mflo $t2 #almacenar LO en t2 finsi: add $t2, $t3, $t2 #t2= t3 + t2 sw $t2, res($0) #almacenar en memoria t2 Disponible en ejercicio1.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
• Identifica la instrucción que determina la condición y controla el flujo de programa. ¿Qué condición se evalúa?
• Identifica el conjunto de instrucciones que implementan la estructura condicional si-entonces.
• ¿Qué valor se almacena en la variable "res" después de ejecutar el programa? • Si dato2=0, ¿Qué valor se almacena en la variable res después de ejecutar el
programa?¿Qué hace entonces el programa? • Dibuja el diagrama de flujo asociado a la estructura de control implementada en
el fragmento de código anterior. • Modifica el código anterior para que la instrucción resaltada en negrita (sumar el
contenido de t0 y t1) se realice después de la estructura de control Si-entonces en lugar de antes, sin modificar el resultado de la ejecución del programa.
Estructura de control condicional Si-entonces con condición compuesta
Segundo ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control condicional Si-entonces:
.data dato1: .word 40 dato2: .word 30 res: .space 4 .text main: lw $t0, dato1($0) #cargar dato1 en t0 lw $t1, dato2($0) #cargar dato2 en t1 and $t2, $t2,$0 #pone a 0 t2 add $t3, $t0, $t1 #t3=t0 + t1 Si: beq $t1, $0, finsi #si t1=0 saltar a finsi beq $t0, $0, finsi #si t0 =0 saltar a finsi entonces: div $t0, $t1 #t0/t1 mflo $t2 #almacenar LO en t2 finsi: add $t2, $t3, $t2 #t2=t2+t3 sw $t2, res($0) #almacenar en memoria t2 Disponible en ejercicio2.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
• ¿Qué condición compuesta se evalúa? • Modifica el código anterior para que la condición evaluada sea ((t1 > 0) y (t0 <>
t1)). Comprueba el correcto funcionamiento ante los siguientes valores: o dato1=40, dato2=30
o dato1=0, dato2=40 o dato1=40, dato2=-40
Estructura de control condicional Si-entonces-sino con condición simple
Tercer ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control Si-entonces-sino.
.data dato1: .word 30 dato2: .word 40 res: .space 4 .text main: lw $t0,dato1($0) lw $t1,dato2($0) Si: bge $t0,$t1,sino entonces: sw $t0, res($0) #almacenar t0 en res j finsi sino: sw $t1, res($0) #almacenar t1 en res finsi: Disponible en ejercicio3.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
• Identifica qué condición se evalúa.
<li<
¿Qué valor se almacena en "res" después de ejecutar el programa? Si dato1=50 y dato2=0, ¿qué valor se almacena en res después de ejecutar el programa? ¿Qué hace entonces el programa?
• Dibuja el diagrama de flujo asociado a la estructura de control implementada en el fragmento de código anterior.
• Identifica en el lenguaje máquina generado por el simulador el conjunto de instrucciones que implementan la pseudoinstrucción bge.
Estructura de control condicional Si-entonces-sino con condición compuesta
Cuarto ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control Si-entonces-sino.
.data dato1: .word 30 dato2: .word 40 dato3: .word -1 res: .space 4 .text main: lw $t1,dato1($0) #cargar dato1 en t1 lw $t2,dato2($0) #cargar dato2 en t2 lw $t3,dato3($0) #cargar dato3 en t3 si: blt $t3, $t1, entonces #si t3 < t1 saltar a entonces ble $t3, $t2, sino #si t3 <= t2 saltar a sino entonces: addi $t4, $0, 1 #t4 = 1 j finsi sino: add $t4, $0,$0 #t4 = 0 finsi: sw $t4, res($0) #almacenar en memoria t4 Disponible en ejercicio4.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
• Identifica qué condición compuesta se evalúa. • ¿Qué valor se almacena en "res" después de ejecutar el programa? Si dato1=40 y
dato2=30, ¿qué valor se almacena en res después de ejecutar el programa? ¿Qué hace entonces el programa?
• Dibuja el diagrama de flujo asociado a la estructura de control implementada en el fragmento de código anterior.
• Modifica el código anterior para que la condición evaluada sea ((dato3>=dato1) y (dato3<=dato2)).
Estructura de control repetitiva para
Quinto ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control repetitiva Para:
.data vector: .word 6,7,8,9,10,-1 res: .space 4 .text main: la $t2, vector #t2 = vector and $t3, $0, $t3 #pone a 0 t3 li $t1, 6 #carga 6 en t1 para: beq $t1, $0, finpara # si t1 = 0 saltar a finpara lw $t4, 0($t2) # carga un elemento del vector en t4 add $t3, $t4, $t3 #acumula la suma de los elementos del vector addi $t2, $t2, 4 #suma 4 a t2 addi $t1, $t1, -1 #resta 1 a t1 j para #saltar a para finpara: sw $t3, res($0) #almacena t3 en res Disponible en ejercicio5a.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
• ¿Qué hace la instrucción "la $t2, vector"? • Identifica en el fragmento de código anterior qué conjunto de instrucciones
constituyen el bucle repetitivo y cuántas veces se va a repetir. • Dentro del bucle se incrementa el contenido del registro t2 en cuatro unidades
cada iteración, ¿por qué? • Dentro del bucle se decrementa el contenido del registro t1 en una unidad en
cada iteración, ¿por qué? • ¿Qué valor se almacena en "res" después de ejecutar el código anterior? ¿Qué
hace entonces el programa? • Dibuja el diagrama de flujo asociado a la estructura de control implementada en
el fragmento de código anterior. • Indica si el siguiente fragmento de código es equivalente al anterior. ¿Cuál de las
dos implementaciones es más óptima? ¿por qué?
.data vector: .word 6,7,8,9,10,-1 res: .space 4 .text main: la $t2, vector #t2 = vector
and $t3, $0, $t3 #pone a 0 t3 li $t0, 1 #carga 1 en t1 li $t1, 6 para: bgt $t0, $t1, finpara # si t1 = 0 saltar a finpara lw $t4, 0($t2) # carga un elemento del vector en t4 add $t3, $t4, $t3 #acumula la suma de los elementos del vector addi $t2, $t2, 4 #suma 4 a t2 addi $t0, $t0, 1 #resta 1 a t1 j para #saltar a para finpara: sw $t3, res($0) #almacena t3 en res Disponible en ejercicio5b.s
Estructura de control repetitiva mientras
Sexto ejercicio
Crea un fichero con el siguiente fragmento de código que implementa una estructura de control repetitiva Mientras:
.data cadena: .asciiz "hola" .align 2 n: .space 4 .text main: la $t0, cadena #cargar la direccion de cadena en t0 andi $t2, $t2, 0 #poner a 0 t2 mientras: lb $t1, 0($t0) #almacena un byte en t1 beq $t1, $0, finmientras #si t1 = 0 saltar a finmientras addi $t2, $t2, 1 #sumar 1 a t2 addi $t0, $t0,1 #sumar 1 a t0 j mientras #saltar a mientras finmientras: sw $t2, n($0) #almacenar t2 en n Disponible en ejercicio6a.s
Borra los valores de la memoria, carga el fichero en el simulador y ejecútalo.
Cuestiones
Parte 7. Gestión de Subrutinas
• Introducción. • Gestión de la pila. • Llamada y retorno de una subrutina. • Llamadas anidadas de subrutinas. • Paso de parámetros. • Bloque de activación de una subrutina. • Problemas propuestos.
Introducción
El diseño de un programa que resuelve un determinado problema puede simplificarse si se plantea adecuadamente la utilización de subrutinas. Éstas permiten dividir un problema largo y complejo en subproblemas más sencillos o módulos, más fáciles de escribir, depurar y probar que si se aborda directamente el programa completo. De esta forma se puede comprobar el funcionamiento individual de cada rutina y, a continuación, integrar todas en el programa que constituye el problema global de partida. Otra ventaja que aporta la utilización de subrutinas es que en ocasiones una tarea aparece varias veces en el mismo programa; si se utilizan subrutinas, en lugar de repetir el código que implementa esa tarea en los diferentes puntos, bastará con incluirlo en una subrutina que será invocada en el programa tantas veces como sea requerida. Yendo más lejos, subproblemas de uso frecuente pueden ser implementados como rutinas de utilidad (librerías), que podrán ser invocadas desde diversos módulos.
Con el fin de dotar de generalidad a una subrutina, ésta ha de ser capaz de resolver un problema ante diferentes datos que se le proporcionan como parámetros de entrada cuando se le llama. Por tanto, para una correcta y eficaz utilización de las subrutinas es necesario tener en cuenta, por un lado, la forma en que se realizan las llamadas y, por otro, el paso de parámetros.
Como paso previo a la realización de la práctica se van a realizar algunos ejercicios sencillos que nos ayuden al manejo de la pila, estructura muy utilizada para una buena gestión de las subrutinas.
Gestión de la pila
Una pila es una estructura de datos caracterizada por que el último dato que se almacena es el primero que se obtiene después. Para gestionar la pila se necesita un puntero a la última posición ocupada de la misma, con el fin de conocer dónde se tiene que dejar el
siguiente dato a almacenar, o para saber dónde están situados los últimos datos almacenados en ella. Para evitar problemas, el puntero de pila siempre debe estar apuntando a una palabra de memoria. Por precedentes históricos, el segmento de pila siempre "crece" de direcciones superiores a direcciones inferiores. Las dos operaciones más típicas con esta estructura son:
Transferir datos hacia la pila (push o apilar). Antes de añadir un dato a la pila se tienen que restar 4 unidades al puntero de pila.
Transferir datos desde la pila (pop o desapilar). Para eliminar datos de la pila, después de extraído el dato se tienen que sumar 4 unidades al puntero de pila.
El ensamblador del MIPS tiene reservado un registro, $sp, como puntero de pila (stack pointer). Para realizar una buena gestión de la pila será necesario que este puntero sea actualizado correctamente cada vez que se realiza una operación sobre la misma.
El siguiente fragmento de código muestra cómo se puede realizar el apilado de los registros $t0-$t1 en la pila:
Primer ejercicio
.text main: li $t0,10 li $t1, 13 #inicializar reg. t0,t1 addi $sp, $sp, -4 #actualizar el sp sw $t0, 0($sp) #apilar t0 addi $sp, $sp, -4 #actualizar el sp sw $t1, 0($sp) #apilar t1 Disponible en ejercicio1.s
Edita el programa, reinicializa el simulador y carga el programa.
Cuestiones
Ejecuta el programa paso a paso y comprueba en qué posiciones de memoria, pertenecientes al segmento de pila se almacena el contenido de los registros t0-t1.
Modifica el programa anterior para que en lugar de actualizar el puntero de pila cada vez que se pretende apilar un registro en la misma, se realice una sola vez al principio y después se apilen los registros en el mismo orden.
Añade el siguiente código al programa original después de la última instrucción:
o Modifica el contenido de los registros t0-t1, realizando algunas operaciones sobre ellos.
o Recupera el contenido inicial de estos registros desapilándolos de la pila, y actualiza el puntero de pila correctamente (limpiar la pila).
Ejecuta el programa resultante y comprueba si finalmente t0-t1 contienen los datos iniciales que se habían cargado. Comprueba también que el contenido del registro sp es el mismo antes y después de la ejecución del programa.
Implementa el siguiente programa:
o Almacena en memoria una tira de caracteres de máximo 10 elementos. o Lee la cadena de caracteres desde el teclado. o Invierte esta cadena, almacenando la cadena resultante en las mismas
posiciones de memoria que la original. (Sugerencia para realizar el ejercicio: Apila los elementos de la tira en la pila y, a continuación, se desapilan y se almacenan en el mismo orden que se extraen).
Llamada y retorno de una subrutina
El juego de instrucciones del MIPS R2000 dispone de una instrucción específica para realizar la llamada a una subrutina, jal etiqueta. La ejecución de esta instrucción conlleva dos acciones:
• Almacenar la dirección de memoria de la siguiente palabra a la que contiene la instrucción jal en el registro ra.
• Llevar el control de flujo de programa a la dirección etiqueta.
Por otra parte, el MIPS R2000 dispone de una instrucción que facilita el retorno de una subrutina. Esta instrucción es jr $ra, instrucción de salto incondicional que salta a la dirección almacenada en el registro ra, que justamente es el registro dónde la instrucción jal ha almacenado la dirección de retorno cuando se ha hecho el salto a la subrutina.
Para ejecutar cualquier programa de usuario el simulador xspim hace una llamada a la rutina main mediante la instrucción jal main. Esta instrucción forma parte del código que añade éste para lanzar a ejecución un programa de usuario. Si la etiqueta main no está declarada en el programa se genera un error. Esta etiqueta deberá siempre referenciar la primera instrucción ejecutable de un programa de usuario. Para que cualquier programa de usuario termine de ejecutarse correctamente, la última instrucción ejecutada en éste debe ser jr $ra (salto a la dirección almacenada en el registro ra), que devuelve el control a la siguiente instrucción desde donde se lanzó la ejecución del programa de usuario. A partir de este punto se hace una llamada a una función del sistema que termina la ejecución correctamente.
Segundo ejercicio
El siguiente código es un programa que realiza la suma de dos datos contenidos en los registros a0 y a1.
.text main: li $a0,10 li $a1,20 add $v1,$a0,$a1 jr $ra Disponible en ejercicio2.s
Reinicializa el simulador, carga el programa y ejecútalo paso a paso, contestando a las siguientes cuestiones:
Cuestiones
¿Cuál es el contenido del PC y del registro ra antes y después de ejecutar la instrucción jal main?
¿Cuál es el contenido de los registros PC y ra antes y después de ejecutar la instrucción jr $ra?
Reinicializa el simulador, carga el programa de nuevo y ejecútalo todo completo. Comprueba que la ejecución termina correctamente sin que salga el mensaje de error que salía en ejecuciones anteriores cuando no se incluía la instrucción jr $ra.
Llamadas anidadas de subrutinas
Cuando una subrutina llama a otra utilizando la instrucción jal se modifica automáticamente el contenido del registro $ra con la dirección de retorno (dirección de memoria de la siguiente palabra a la que contiene la instrucción que ha efectuado el salto). Esto hace que se pierda cualquier contenido anterior que pudiera tener este registro, que podría ser a su vez otra dirección de retorno suponiendo que se llevan efectuadas varias llamadas anidadas. Así pues, en cada llamada a una subrutina se modifica el contenido del registro ra, y sólo se mantiene en este registro la dirección de retorno asociada a la última llamada, ¿Qué ocurre entonces con todas las direcciones de retorno que se deberían guardarse en llamadas anidadas?
Una solución a este problema es que antes de ejecutar una llamada desde una subrutina a otra se salve el contenido del registro ra en la pila. Como la pila crece dinámicamente, las direcciones de retorno de las distintas llamadas anidadas quedarán almacenadas a medida que éstas se van produciendo. La última dirección de retorno apilada estará en el tope de la pila, y ésta es justamente la primera que se necesita recuperar. Así pues, una pila es la estructura adecuada para almacenar las direcciones de retorno en llamadas anidadas a subrutinas.
Tercer ejercicio
El siguiente código implementa una llamada anidada a dos subrutinas, rutina main y subr. A la primera se le llamará desde el fragmento de código que tiene el simulador para lanzar la ejecución de un programa de usuario y a la subrutina subr se la llamará desde main. La primera necesita apilar la dirección de retorno (contenido de ra) para que sea posible la vuelta a la instrucción siguiente desde donde se hizo la llamada a la rutina main. La segunda como no hace ninguna llamada a otra subrutina no necesita apilar el contenido de ra:
.data suma: .space 4 .text main: addi $sp, $sp, -4 #apilar dir. ret. sw $ra,0($sp) li $a0,10 li $a1,2 jal subr sw $v0,suma($0) lw $ra, 0($sp) #desapilar dir. ret. addi $sp,$sp,4 jr $ra subr: add $v0, $a0,$a1 jr $ra Disponible en ejercicio3.s
Reinicializa el simulador, carga el programa y ejecútalo paso a paso respondiendo a las siguientes cuestiones:
Cuestiones
Comprueba qué contiene el registro ra y el PC antes y después de ejecutar la instrucción jal main.
Comprueba qué hay almacenado en el tope de la pila después de ejecutar las dos primeras instrucciones del programa.
Comprueba el contenido de los registros ra y PC antes y después de ejecutar la instrucción jal subr.
Comprueba el contenido de los registros ra y PC antes y después de ejecutar la instrucción jr $ra que está en la subrutina subr.
Comprueba el contenido de los registros ra y PC antes y después de ejecutar la instrucción jr $ra que está en la subrutina main.
¿Qué hubiera ocurrido si antes de ejecutar la instrucción jr $ra de esta subrutina main no se hubiese desapilado el contenido del registro ra?
Añade el código necesario para realizar las siguientes modificaciones sobre el código original:
o La subrutina subr debería calcular la siguiente operación $v0=$a0 DIV $a1. Esta división sólo se realizará si ambos operandos son mayores que 0. La comprobación se realizará en una segunda subrutina llamada comp que almacenará en v0 un 1, si los datos contenidos en los registros a0 y a1 son mayores que 0, y un 0 en caso contrario. La llamada a esta segunda subrutina se realizará desde la subrutina subr, y &eeacute;sta almacenará en v0 el cociente de la división, si &eacue;sta se realiza y un -1 en caso contrario.
Paso de parámetros
A la hora de implementar una subrutina hay que decidir:
Parámetros a pasar a la rutina.
Tipo de parámetros:
por valor: se pasa el valor del parámetro, por referencia: se pasa la dirección de memoria donde esté
almacenado el parámetro.
Lugar donde se van a pasar los parámetros:
registros, pila
El ensamblador del MIPS establece el siguiente convenio para realizar el paso de parámetros:
Los 4 primeros parámetros de entrada se pasarán a través de los registros $a0-$a3. A partir del quinto parámetro se pasaría a través de la pila.
Los dos primeros parámetros de salida se devuelven a través de los registros $v0-$v1, el resto a través de la pila.
Cuarto ejercicio
El siguiente programa implementa la llamada a una subrutina y el código de la misma, que devuelve una variable booleana que vale 1 si una determinada variable está dentro de un rango y 0, en caso contrario. La subrutina tendrá los siguientes parámetros:
Parámetros de entrada:
Las dos variables que determinan el rango, pasados por valor, a través de a0 y a1.
La variable que se tiene que estudiar si está dentro del rango, pasada por valor, a través de a2.
Parámetros de salida:
Variable booleana que indica si la variable estudiada está o no dentro del rango, por valor, devuelto a través de v0.
.data rango1: .word 10 rango2: .word 50 dato: .word 12 res: .space 1 .text main: addi $sp,$sp,-4 sw $ra,0($sp) #apilar ra lw $a0,rango1($0) #a0=rango1 lw $a1,rango2($0) #a1=rango2 lw $a2,dato($0) #a2=dato jal subr #saltar a subr sb $v0,res($0) #res=v0 lw $ra,0($sp) addi $sp,$sp,4 #desapilar ra jr $ra #terminar ejecucion programa subr: blt $a2,$a0,sino #Si a2a1 saltar a sino entonces: addi $v0, $0,1 #v0=1 j finsi #saltar a finsi sino: add $v0,$0,$0 #v0=0 finsi: jr $ra #retornar Disponible en ejercicio4.s
Reiniciliza el simulador, carga el programa, ejecútalo y comprueba el resultado almacenado en la posición de memoria res.
Cuestiones
Identifica las instrucciones que se necesitan en:
El programa que hace la llamada para: 1. La carga de parámetros en los registros. 2. La llamada a la subrutina. 3. El almacenamiento del resultado.
La subrutina para: 1. La lectura y procesamiento de parámetros. 2. La carga del resultado en v0 3. El retorno al programa que ha hecho la llamada.
Modifica el código anterior para que los parámetros que se pasan a la subrutina subr, tanto los de entrada como el de salida, se pasen por referencia. Los pasos a realizar tanto por el programa que hace la llamada como por la subrutina son los siguientes:
En el programa que hace la llamada: 1. Cargar la dirección de los parámetros en los registros
correspondientes (entrada y salida). 2. Llamada a la subrutina.
En la subrutina: 1. Lectura de los parámetros de entrada a partir de las
direcciones pasada como parámetro. 2. Procesamiento de los parámetros de entrada y generación
del resultado. 3. Almacenamiento del resultado en la dirección de memoria
pasada a través del parámetro de salida 4. Retorno al programa que hizó la llamada.
Ejecuta el programa obtenido y comprueba que el resultado obtenido es el mismo que el del programa original.
Modifica el código anterior para que los parámetros de entrada a la subrutina se pasen por valor mediante la pila y el de salida se pase también a través de la pila pero por referencia. A continuación se muestra un esquema de cómo debe ser la situación de la pila en el momento que empieza a ejecutarse la subrutina:
rango1 + rango 2 dato sp --> res -
Bloque de activación de la subrutina
El bloque de activación de la subrutina es el segmento de pila que contiene toda la información referente a una llamada a una subrutina (parámetros pasados a través de la pila, registros que modifica la subrutina y variables locales). Un bloque típico abarca la memoria entre el puntero de bloque (normalmente llamado regisro $fp en el ensamblador del MIPS, se trata del registro 30), que apunta a la primera palabra almacenada en el bloque, y el puntero de pila ($sp), que apunta a la última palabra del bloque. El puntero de pila puede variar su contenido durante la ejecución de la subrutina y, por lo tanto, las referencias a una variable local o a un parámetro pasado a través de la pila podrían tener diferentes desplazamientos relativos al puntero de pila dependiendo de dónde estuviera éste en cada momento. De forma alternativa, el puntero de bloque apunta a una dirección fija dentro del bloque. Así pues, la subrutina en ejecución
usa el puntero de bloque de activación para acceder mediante desplazamientos relativos a éste a cualquier elemento almacenado en el bloque de activación independientemente de dónde se encuentre el puntero de pila.
Los bloques de activación se pueden construir de diferentes formas. No obstante, lo que realmente importa es que el programa que hace la llamada y la subrutina deben estar de acuerdo en la secuencia de pasos a seguir. Los pasos que se enumeran a continuación describen la convención de llamada y retorno de una subrutina que se adopta. Esta convención interviene en tres puntos durante una llamada y retorno a una subrutina: Inmediatamente antes de llamar a la subrutina e inmediatamente después del retorno de la misma, en el programa que hace la llamada, en el momento justo en el que la subrutina empieza su ejecución e inmediatamente antes de realizar el retorno en la subrutina:
o En el programa que hace la llamada: Inmediatamente antes de hacer la llamada a la subrutina:
Se deben cargar los parámetros de entrada (y los de salida si se pasan por referencia) en los lugares establecidos, los cuatro primeros en registros y el resto en la pila.
Inmediatamente despus del retorno de la subrutina: Se debe limpiar la pila de los parámetros almacenados en
ella, actualizando el puntero de pila. o En la subrutina:
En el momento que empieza la ejecución: Reservar espacio en la pila para apilar todos los registros
que la subrutina vaya a modificar y para las variables locales que se almacenarán en la pila.
Puesto que el registro $fp es uno de los registros modificados por la subrutina, va a ser utilizado como puntero al bloque de activación, deberá apilarse. Para que la posterior limpieza del bloque de activación sea más sencilla, conviene apilarlo como primera palabra detrás de los parámetros que ha apilado el programa que ha hecho la llamada (si los hubiese).
Actualizar el contenido del registro fp, para que apunte a la posición de la pila donde acabamos de almacenar el contenido del fp.
Apilar el contenido del resto de registros que se van a modificar, que pueden ser: $t0-$t9, $s0-$s7, $a0-$a3, $ra.
Inmediatamente antes del retorno: Recuperar el contenido de los registros apilados y
actualizar el puntero de pila para limpiar la pila.
El Bloque de activación de una subrutina tendría, por lo tanto, la siguiente estructura:
Parámetros 5,6....
+ Parámetros apilados por el programa que hace la llamada
fp --> Registro fp Registros apilados por la subrutina
Registro ra Registros
a0-a3 Registros
s0-s7 Registros
t0-t9
sp -->
variables locales
-
Quinto ejercicio
El siguiente programa implementa una subrutina que calcula los elementos nulos de un vector. Los parámetros que se le pasan son:
o Parámetros de entrada: La dimensión del vector (pasado por valor). La dirección del primer elemento del vector (pasado por
referencia). Estos parámetros se pasarán a través de la pila ya que el objetivo que se pretende remarcar con este programa es la gestión del bloque de activación de una subrutina. Según el convenio establecido, estos parámetros se pasarían a través de los registros a0 y a1.
o Parámetros de salida: Contador de elementos nulos del vector.
Este parámetro se devolverá a traves del registro v0.
En la subrutina se termina de crear el bloque de activación de la subrutina, que estará formado por los parámetros que se han pasado a través de la pila (parámetros de entrada) y por los registros que vaya a modificar la subrutina, que apilará al principio de la ejecución de la subrutina. No se reserva espacio para variables locales puesto que se utilizan registros para almacenarlas.
Por otro lado, para que se pueda apreciar mejor la evolución del bloque de activación de la subrutina en distintos puntos del programa, en el programa main lo primero que se hace es inicializar los registros s0, s1, s2 y fp a unos valores. Al finalizar la ejecución del programa el contenido de estos registros debería ser el mismo.
.data n1: .word 4 vec1: .word 1,0,0,2 nul1: .space 4 .text #en primer lugar se inicializan los registros s0, s1, s2 y fp main: li $s0,1 li $s1,2 li $s2,3 li $fp,4
addi $sp,$sp,-4 sw $ra,0($sp) addi $sp, $sp,-8 lw $t0, n1($0) sw $t0,4($sp) la $t0, vec1 sw $t0, 0($sp) jal subr ret: addi $sp,$sp,8 sw $v0,nul1($0) lw $ra,0($sp) addi $sp,$sp,4 jr $ra subr: addi $sp,$sp,-16 sw $fp, 12($sp) addi $fp,$sp,12 sw $s0,-4($fp) sw $s1,-8($fp) sw $s2,-12($fp) lw $s0,4($fp) lw $s1,8($fp) and $v0, $v0,$0 #bucle cuenta elem. nulos. bucle: beq $s1,$0,finb # si s1 = 0 saltar a finb lw $s2, 0($S0) # cargar s2=Mem(s0) bne $s2, $0, finsi #si s3<>0 saltar a finsi addi $v0,$v0,1 #v0=s2 finsi: addi $s0, $s0,4 # s0 = s0+4 addi $s1, $s1,-1 # s1=s1-1 j bucle #saltar a bucle finb: lw $s0,-4($fp) lw $s1,-8($fp) lw $s2,-12($fp) addi $sp,$fp,0 lw $fp,0($sp) addi $sp,$sp,4 jr $ra Disponible en ejercicio5.s
Cuestiones
Identifica la instrucción o conjunto de intrucciones que realizan las siguientes acciones en programa que hace la llamada a la subrutina subr y en la subrutina:
En el programa que hace la llamada: 1. Carga de parámetros en la pila. 2. Llamada a la subrutina.
3. Limpieza de la pila de los parámetros pasados a través de ella.
4. Almacenamiento del resultado. En la subrutina:
1. Acutalización del bloque de activación de la subrutina. 2. Lectura de los parámetros de la pila y procesamiento de
los mismos. 3. Carga del resultado en v0. 4. Desapilar bloque de activación los registros apilados y
eliminar las variables locales. Actualizar el puntero de pila.
5. Retorno al programa que ha hecho la llamada.
Ejecuta paso a paso el programa anterior y dibuja la situación del bloque de activación y de los registros s0, s1, s2, fp, sp, ra y PC en cada una de las siguientes situaciones:
Programa que hace la llamada a la subrutina subr, hasta el momento que hace la llamada:
1. Antes y después de ejecutar la instrucción addi $sp, $sp, -8 (situación uno).
2. Antes y despueacute;s de ejecutar la instrucción jal subr. (situación justo antes de llamar a la subrutina)
Subrutina: 1. Después de ejecutar la instrucción addi $sp, $sp, -16. 2. Después de ejecutar la instrucción sw $fp, 12($sp). 3. Después de ejecutar la instrucción addi $fp, $sp, 12. 4. Despue´s de ejecutar la instrucción sw $s2, -12($fp). 5. Después de ejecutar la instrucción lw $s0, 4($fp). 6. Después de ejecutar la instrucción lw $s1, 4($fp). 7. Después de ejecutar el bucle (denominado bucle). 8. Antes y después de ejecutar addi $sp, $fp, 0. 9. Después de ejecutar lw $fp, 0($sp). 10. Después de ejecutar addi $sp, $sp, 4. Comprobar qué la
situación de la pila y de los registros sp y fp es la misma que justo antes de llamar a la subrutina).
11. Después de ejecutar jr $ra Programa que hace la llamada después de retornar de la
subrutina: 1. Antes y después de ejecutar addi sp, sp, 8. Comprobar qué
el contenido de los registros y de la pila se corresponde con la situación uno.
Modifica el código para que los parámetros se pasen a través de los registros $a0-$a1 y el de salida a través de v0. Supongamos que el programa que hace la llamada pretende que después de ejecutar la subrutina estos registros contengan el mismo contenido que el que se ha cargado inicialmente en el programa.
Problemas propuestos
Implementa una subrutina en ensamblador que calcule cuántos elementos de un vector de enteros de dimensión n son iguales a un elemento dado:
Parámetros de entrada a la subrutina: 1. dirección del primer elemento del vector, 2. total de elementos del vector (dimensión), 3. elemento a comparar.
Parámetro de salida de la subrutina: 1. contador calculado.
Realiza las siguientes implementaciones: Implementa la subrutina de forma que todos los parámetros que se le
pasan sean por valor excepto aquéllos que obligatoriamente se deban pasar por referencia, y a través de registros.
Implementa la subrutina de forma que todos los parámetros se pasen por referencia y a través de registros.
Implementa la subrutina donde los parámetros que se pasan sean del mismo tipo que en el primer caso pero utilizando la pila como lugar para realizar el paso de parámetros.
Implementa una subrutina en ensamblador, tal que dado un vector de enteros de dimensión n obtenga el elemento (i) de dicho vector. La subrutina tendrá como parámetros de entrada: la dirección del vector, la dimensión del mismo y el del elemento a devolver. La subrutina devolverá el elemento i-ésimo. Realiza la llamada y el retorno a la subrutina según el convenio establecido.
Implementa una subrutina en ensamblador, tal que dada una matriz de enteros de dimensión n x m, almacenada por filas, obtenga el elemento (i,j) de dicha matriz. La subrutina tendrá como parámetros de entrada: la dirección de la matriz, las dimensiones de la misma y los índices elemento a devolver. La subrutina devolverá el elemento (i,j). Realiza la llamada y el retorno a la subrutina según el convenio establecido.
<--Estructuras de control El simulador SPIM > -->
Examen de TeoríaFundamentos de Computadores de Ingeniería InformáticaFacultad de Informática. Universidad de Las Palmas de GC
15 de diciembre de 2005
1. (2 puntos) Ha aparecido en el mercado una nueva versión de un procesadoren la que la única mejora con respecto a la versión anterior es una unidad decoma �otante mejorada que permite reducir el tiempo de las instruccionesde coma �otante a tres cuartas partes del tiempo que consumían antes.Suponga que en los programas que constituyen la carga de trabajo habitualdel procesador las instrucciones de coma �otante consumen un promediodel 13% del tiempo del procesador antiguo:
a) (0.75 puntos) ¾Cuál es la máxima ganancia de velocidad que puedeesperarse en los programas si se sustituye el procesador de la versiónantigua por el nuevo?
b) (1.25 puntos) ¾Cuál debería ser el porcentaje de tiempo de cálculo condatos en coma �otante (en la versión antigua del procesador) en susprogramas para esperar una ganancia máxima de 4?
2. (3 puntos) El tratamiento de las excepciones del procesador MIPS básicoconsiste en la escritura de la dirección de la instrucción causante de la ex-cepción en el registro EPC, la escritura en el registro Cause de la causade la excepción (0 para instrucción desconocida y 1 para desbordamien-to aritmético) y la ruptura del secuenciamiento de las instrucciones a ladirección 0x0C000000.Las �guras 1 y 2 son la ruta de datos y la especi�cación del control parael procesador MIPS básico.Realiza las modi�caciones de la ruta de datos y especi�ca el control me-diante una tabla de verdad para incluir el tratamiento de las excepcionestal y como ha sido de�nido anteriormente.
3. (2.0 puntos) Las �guras 3 y 4 representan la ruta de datos y la especi�cacióndel control para la implementación multiciclo del procesador MIPS básico
1
con la inclusión del hardware y control necesarios para tratar las excepcio-nes por instrucción desconocida y desbordamiento aritmético. Además, las�guras 5 y 6 especi�can el control microprogramado de la implementaciónmulticiclo del procesador MIPS básico. Realiza las modi�caciones necesa-rias del microprograma y del secuenciador del microprograma de la �gura7 para que incluya el tratamiento de excepción por desbordamiento arit-mético. Es necesario especi�car el contenido de las ROM de "dispatch"quehayan sido modi�cadas. El tratamiento de la excepción por instruccióndesconocida no es necesario incluirlo.
4. (0.5 puntos) Cambia el valor de los bits 3, 7, 9, 21, 29 (sin modi�car el restode los bits) de la posición de memoria etiquetada palabra y de contenido0xFF0F1235 almacenada en memoria a partir de la dirección 0x10000004.
5. (2.5 puntos) Diseña un programa en ensamblador que dado un vector deenteros V obtenga cuántos elementos de este vector están dentro del rangodeterminado por dos variables rango1 y rango2 (ambos inclusives). El pro-grama deberá inicializar los elementos del vector en memoria, una variableque almacenará el número de elementos que tiene ese vector y dos variablesdonde se almacenarán los rangos. También deberá reservar espacio para lavariable resultante.
2
PC
Inst
ruct
ion
mem
ory
Rea
dad
dres
s
Inst
ruct
ion
[31–
0]
Inst
ruct
ion
[20
16]
Inst
ruct
ion
[25
21]
Add
Inst
ruct
ion
[50]
Mem
toRe
gA
LUO
pM
emW
rite
Reg
Writ
e
Mem
Rea
dB
ranc
hR
egDs
t
ALU
Src
Inst
ruct
ion
[31
26]
4
1632
Inst
ruct
ion
[15
0]
0
0M u x0 1Co
ntro
l
Add
ALU
resu
lt
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Read
data
1
Read
data
2
Read
regi
ster
1
Read
regi
ster
2
Sign
exte
nd
M u x 1
ALU
resu
lt
Zero
PCSr
c
Dat
am
emor
yW
rite
data
Rea
dda
taM u x1
Inst
ruct
ion
[15
11]
ALU
cont
rol
Shift
left
2
ALU
Addr
ess
PC
Inst
ruct
ion
mem
ory
Rea
dad
dres
s
Inst
ruct
ion
[31–
0]
Inst
ruct
ion
[20
16]
Inst
ruct
ion
[25
21]
Add
Inst
ruct
ion
[50]
Mem
toRe
gA
LUO
pM
emW
rite
Reg
Writ
e
Mem
Rea
dB
ranc
PC
Inst
ruct
ion
mem
ory
Rea
dad
dres
s
Inst
ruct
ion
[31–
0]
Inst
ruct
ion
[20
16]
Inst
ruct
ion
[25
21]
Add
Inst
ruct
ion
[50]
Mem
toRe
gA
LUO
pM
emW
rite
Reg
Writ
e
Mem
Rea
dB
ranc
hR
egDs
t
ALU
Src
Inst
ruct
ion
[31
26]
4
1632
Inst
ruct
ion
[15
0]
0
0M u x0 1Co
ntro
l
Add
ALU
resu
lt
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Read
data
1
Read
data
2
Read
regi
ster
1
Re
hR
egDs
t
ALU
Src
Inst
ruct
ion
[31
26]
4
1632
Inst
ruct
ion
[15
0]
0
0M u x0 1Co
ntro
l
Add
ALU
resu
lt
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Read
data
1
Read
data
2
Read
regi
ster
1
Read
regi
ster
2
Sign
exte
nd
M u x 1
ALU
resu
lt
Zero
PCSr
c
Dat
am
emor
yW
rite
data
Rea
dda
taM u x1
Inst
ruct
ion
[15
11]
ALU
cont
rol
Shift
left
2
ALU
Addr
ess
Figura 1: Ruta de datos monociclo
3
Op5
-0 -
>(b
its 3
1-26
)00
000
00 D
10 0
011
35D
10 1
011
43D
00 0
100
4 DR
-For
mat
lwsw
beq
Reg
Dst
10
xx
AL
US
rc0
11
0M
emT
oR
eg0
1x
xR
egW
rite
11
00
Mem
Rea
d0
10
0M
emW
rite
00
10
Bra
nch
00
01
AL
UO
p1
10
00
AL
UO
p0
00
01
R-fo
rmat
Iwsw
beq
Op0
Op1
Op2
Op3
Op4
Op5
Inpu
ts
Out
puts
Reg
Dst
ALU
Src
Mem
toR
eg
Reg
Writ
e
Mem
Rea
d
Mem
Writ
e
Bra
nch
ALU
Op1
ALU
OpO
Imp
lem
enta
ción
con
PLA
R-fo
rmat
Iwsw
beq
Op0
Op1
Op2
Op3
Op4
Op5
Inpu
ts
Out
puts
Reg
Dst
ALU
Src
Mem
toR
eg
Reg
Writ
e
Mem
Rea
d
Mem
Writ
e
Bra
nch
ALU
Op1
ALU
OpO
R-fo
rmat
Iwsw
beq
Op0
Op1
Op2
Op3
Op4
Op5
Inpu
ts
Out
puts
Reg
Dst
ALU
R-fo
rmat
Iwsw
beq
Op0
Op1
Op2
Op3
Op4
Op5
Inpu
ts
Out
puts
Reg
Dst
ALU
Src
Mem
toR
eg
Reg
Writ
e
Mem
Rea
d
Mem
Writ
e
Bra
nch
ALU
Op1
ALU
OpO
Imp
lem
enta
ción
con
PLA
Figura 2: Control monociclo
4
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Out
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26] ]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Out
Figura 3: Camino de datos con excepciones5
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op=
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
A
'BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
Figura 4: Especi�cación del control con excepciones
6
C o n tro l A L U
A L U o p 1 A L U O p 0O p e ra c ió n
0 0 S u m a
0 1 R e s ta
1 0 F u n c . c o d e
S R C 2
A LU S rB 1 A LU S rcB 0O perac ión
0 0 B
0 1 4
1 0 E xtend
1 1 E xtS hft
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
S R C 1
A d d rS rc AO p e ra c ió n
0 P C
1 A
Figura 5: Campos y codi�cación de los valores de las microinstrucciones
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
Src
A
ALU
Src
B1
ALU
Src
B0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sou
rce1
PC
Sou
rce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
Figura 6: Microprograma
7
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
Figura 7: Secuenciador del microprograma
8
Examen de TeoríaFundamentos de Computadores de Ingeniería InformáticaFacultad de Informática. Universidad de Las Palmas de GC
7 de septiembre de 2005
1. (3.0 puntos) La �gura 1 representa una ruta de datos alternativa para laimplementación multiciclo del procesador MIPS básico estudiado. En estaimplementación, los registros temporales A y B han sido eliminados conla intención de realizar en un único ciclo un acceso de lectura al banco deregistro y una operación ALU.La �gura 2 es la especi�cación del control multiciclo para el procesadorMIPS básico estudiado y es incluida aquí por si fuera de ayuda.Escribe la especi�cación completa de la nueva unidad de control para estanueva ruta de datos que incluya el control para las instruciones load, store,aritméticas y jump. El control para la instrucción beq no es necesariohacerlo.
2. (1.5 puntos) Considera que una ventaja de la nueva implementación delprocesador es la reducción de los ciclos por instrucción en una unidadpara todas las instrucciones, mientras que una desventaja es el aumentodel tiempo de ciclo. A partir de la mezcla de instrucciones de la tabla1, ¾Cuál es el máximo incremento de frecuencia permitido para la nuevaimplementación respecto a la implementación original (en tanto por ciento)para que la propuesta no haga más lento la ejecución del programa gcc?
Tipo Frecuencia (%)Tipo-R 41Load 24Store 14Saltos y bifurcaciones 21
Cuadro 1: Frecuencia simpli�cada de usos de las instrucciones para el programa gcc
3. (2.5 puntos) Las �guras 3 y 4 especi�can el control microprogramado de laimplementación multiciclo del procesador MIPS básico estudiado. Realizalas modi�caciones necesarias del microprograma para que sea válido parala ruta de datos de la �gura 1.
1
Figura 1: Camino de datos con excepciones2
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op=
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
A
'BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
Figura 2: Especi�cación del control con excepciones
3
C o n tro l A L U
A L U o p 1 A L U O p 0O p e ra c ió n
0 0 S u m a
0 1 R e s ta
1 0 F u n c . c o d e
S R C 2
A LU S rB 1 A LU S rcB 0O perac ión
0 0 B
0 1 4
1 0 E xtend
1 1 E xtS hft
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
S R C 1
A d d rS rc AO p e ra c ió n
0 P C
1 A
Figura 3: Campos y codi�cación de los valores de las microinstrucciones
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
Src
A
ALU
Src
B1
ALU
Src
B0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sou
rce1
PC
Sou
rce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
Figura 4: Microprograma
4
Examen de TeoríaFundamentos de Computadores de Ingeniería InformáticaFacultad de Informática. Universidad de Las Palmas de GC
13 de julio de 2005
1. (3 puntos) La instrucción Move Conditional on Zero MOVZ rd, rs, rt esuna instrucción tipo R del repertorio de instrucciones del procesador MIPSque mueve condicionalmente el registro rs al registro rd cuando el registrort es igual 0. El formato de la instrucción es el siguiente:b31 . . . b26 b25 . . . b21 b20 . . . b16 b15 . . . b11 b10 . . . b6 b5 . . . b0
0 . . . 0 rs rt rd 0 . . . 0 0 0 1 0 1 0
a) (1.5 puntos) Añada los caminos de datos y las señales de control ne-cesarias al camino de datos multiciclo de la �gura 1 para la ejecuciónde esta instrucción.
b) (1.5 puntos) Indique las modi�caciones necesarias de la máquina deestados �nitos de la �gura 2 para la inclusión de la instrucción MOV Z.
2. (1.5 puntos) Una ventaja de incluir la instrucción MOVZ en el repertoriode instrucciones consiste en la posibilidad de sustituir cada pieza de códigocon la siguiente estructura:
bne rs, nocopiaradd rd, rt, r0
nocopiar: . . .por el código:
movz rd, rs, rtTen en cuenta que cuando hacemos esta sustitución disminuye el númerode instrucciones del programa y también el número de ciclos de ejecución(de 3 ciclos del beq más 4 ciclos del add pasamos a 4 ciclos del movz ).Considerando que esta mejora es aplicable sólo al 2 por ciento del totalde las instrucciones de salto y bifurcación, calcula la máxima mejora derendimiento introducida al incluir esta instrucción en el repertorio de ins-trucciones para el programa gcc que tiene la distribución de instruccionesdel cuadro 1.
1
Tipo Frecuencia (%)Tipo-R 41Load 24Store 14Saltos y bifurcaciones 21
Cuadro 1: Frecuencia simpli�cada de usos de las instrucciones para el programa gcc
3. (2.5 puntos) Las �guras 1 y 2 representan la ruta de datos y la especi�-cación del control para la implementación multiciclo del procesador MIPSbásico con la inclusión del hardware y control necesarios para tratar las ex-cepciones por instrucción desconocida. Además, las �guras 3 y 4 especi�canel control microprogramado de la implementación multiciclo del procesa-dor MIPS básico. Realiza las modi�caciones necesarias del microprogramay del secuenciador del microprograma de la �gura 5 para que incluya eltratamiento de excepción por instrucción desconocida. Es necesario especi-�car el contenido de las ROM de "dispatch"que hayan sido modi�cadas. Eltratamiento de la excepción por desbordamiento aritmético no es necesarioincluirlo.
2
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Out
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0
Shift
left
2
Mem
ory
Mem
Dat
a
Writ
eda
ta
M u x0 1
Inst
ruct
ion
[15–
11]
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sign
exte
nd
3216
Inst
ruct
ion
[25–
21]
Inst
ruct
ion
[20–
16]
Inst
ruct
ion
[15–
0]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26] ]
Inst
ruct
ion
regi
ster
ALU
cont
rol
ALU
resu
ltA
LUZ
ero
Mem
ory
data
regi
ster
A B
IorD
Mem
Re
ad
Mem
Wri
te
Mem
toR
eg
PC
Writ
eC
ond
PC
Writ
e
IRW
rite
Con
trol
Out
puts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0]
2628
Sh
iftle
ft2
PC
[31
-28]
1
Addr
ess
EPC
CO
0000
003
Cau
se
AL
UO
p
AL
US
rcB
AL
US
rcA
Re
gDst
PC
So
urce
Re
gWri
te
EP
CW
rite
IntC
ause
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Ca
useW
rite
10
1M u x
0 32
M u x0 1
M u x0 1
PC
M u x0 1
Reg
iste
rsW
rite
regi
ster
Writ
eda
ta
Re
adda
ta1
Re
adda
ta2
Rea
dre
gist
er1
Rea
dre
gist
er2
ALU
Out
Figura 1: Camino de datos con excepciones3
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=01
PC
Writ
eCon
dP
CS
ourc
e=
01
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=10
Reg
Dst
=1
Reg
Writ
eM
emto
Reg
=0
Mem
Writ
eIo
rD=
1M
emR
ead
IorD
=1
ALU
Src
A=
1A
LUS
rcB
=00
ALU
Op
=00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
00
Reg
Writ
eM
emto
Reg
=1
Reg
Dst
=0
ALU
Src
A=
0A
LUS
rcB
=11
ALU
Op
=00
Mem
Rea
dA
LUS
rcA
=0
IorD
=0
IRW
rite
ALU
Src
B=
01A
LUO
p=
00P
CW
rite
PC
Sou
rce
=00
Inst
ruct
ion
fetc
hIn
stru
ctio
nde
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op=
code
/R
egis
ter
fetc
h
Jum
pco
mpl
etio
nB
ranc
hco
mpl
etio
nE
xecu
tion
Mem
ory
addr
ess
com
puta
tion
Mem
ory
acce
ssM
emor
yac
cess
R-t
ype
com
plet
ion
Writ
e-ba
ckst
ep(Op
='L
W')
or(O
p=
'SW
')(O
p=
R-ty
pe)
(Op='BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
A
'BEQ')
(Op='J')
(Op = 'S
W')
(Op='LW')
4
01 9
86
2
711
105
3
Sta
rt
(Op = other)
Ove
rflow
Ove
rflo
w
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=0
Cau
seW
rite
ALU
Src
A=
0A
LUS
rcB
=01
ALU
Op
=01
EP
CW
rite
PC
Writ
eP
CS
ourc
e=
11
IntC
ause
=1
Cau
seW
rite
PC
Writ
eP
CS
ourc
e=
10
Figura 2: Especi�cación del control con excepciones
4
C o n tro l A L U
A L U o p 1 A L U O p 0O p e ra c ió n
0 0 S u m a
0 1 R e s ta
1 0 F u n c . c o d e
S R C 2
A LU S rB 1 A LU S rcB 0O perac ión
0 0 B
0 1 4
1 0 E xtend
1 1 E xtS hft
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
R e g is te r C o n tro l
R e g W rite R e g D s t M e m T o R e gO p e r .
1 1 0 W rite A L U
1 0 1 W rite M D R
M e m o ria
IR W rite M e m R e a d M e m W rite Io rDO p e r.
1 1 0 0 R e ad P C
0 1 0 1 R e ad A L U
0 0 1 1 W rite A L U
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fe tch
0 1 D ispatch1
1 0 D ispatch2
S R C 1
A d d rS rc AO p e ra c ió n
0 P C
1 A
Figura 3: Campos y codi�cación de los valores de las microinstrucciones
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
Src
A
ALU
Src
B1
ALU
Src
B0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sou
rce1
PC
Sou
rce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
Figura 4: Microprograma
5
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
State
Op
Adder
1
PLA or ROM
Mux3 2 1 0
Dispatch ROM 1Dispatch ROM 2
0
AddrCtl
Address select logic
Instruction registeropcode field
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq .
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Dispatch ROM1Op [5:0] Nombre Valor
000000 R-Format R-Format1 (6)000010 jmp JUMP1 (9)000100 beq BEQ1 (8)100011 lw MEM1 (2)101011 sw MEM1 (2)
Dispatch ROM2Op [5:0] Nombre Valor
100011 lw LW2 (3)101011 sw SW2 (5)
Figura 5: Secuenciador del microprograma
6
Examen de Fundamentos de Computadores de IIFacultad de Informatica. Universidad de Las Palmas de GC
7 de septiembre de 2004
1. (0.75 puntos) El formato de instruccion de un procesadortiene6 bits parael codigo de operacion y10 para la direccion del operando. Suponiendo queuna instruccion de bifurcacion con direccionamiento relativo al contadorde programa, almacenada en la posicion530 (en decimal), origina un saltoa la posicion620 (en decimal), y si ademas el codigo de operacion de lainstruccion de salto es110011, justifica una posible codificacion binaria dedicha instruccion.
2. (1.25 puntos) En un procesador con instrucciones de0 direcciones (proce-sador con pila), ¿que expresion matematica calcula la secuencia de instruc-ciones?PUSH M [C]PUSH M [D]ADD
PUSH M [C]PUSH M [D]ADD
MULT
POP M [A]
3. Suponga que hubiera una instruccion MIPS llamadabcp, que copiara unbloque de palabras de una direccion a otra. Suponga que estainstruccionrequiera que la direccion del principio del bloque fuente sea el registrot1,la direccion destino este en el registrot2, y el numero de palabras a copiareste ent3 (que es≥ 0). Ademas suponga que los valores de estos registros,ası como el registrot4 puedan destruirse al ejecutar esta instruccion (paraque los registros puedan usarse como temporales).
(2 puntos)Escriba un programa en lenguaje en ensamblador MIPS sus-titutivo de la instruccionbcp para realizar la copia del bloque. ¿Cuantasinstrucciones se ejecutaran para copiar un bloque de100 palabras?Utilizando el CPI de las instrucciones en la realizacion multiciclo,¿cuantos ciclos se necesitan para copiarn palabras?
1
(2 puntos) Disene una estrategia para incluir la instruccionbcp al cami-no de datos de la figura 1 y a la especificacion del control de lafigura2. Probablemente se necesitara hacer algunos cambios en elcamino dedatos para realizar la instruccion eficientemente. De unadescripcionde los cambios propuestos y de como funciona el secuenciamiento dela instruccion.
(2 puntos) Modifique el formato original de las microinstruccionesMIPS (figura 3) y el microprograma inical (figura 4) para que incluyala instruccionbcp. Describa detalladamente como se extiende el mi-crocodigo para soportar estructuras de control mas complejas (comoun bucle) con microcodigo. ¿Ha cambiado el soporte para la instruc-cion bcp el tamano del codigo? Ademas de la instruccionbcp, ¿algunaotra instruccion se vera afectada por el cambio en el formato de ins-trucciones?
(2 puntos) Estime la mejora del rendimiento que se puede conseguiral realizar la instruccion en circuiterıa (respecto de lasolucion porprograma del apartado anterior) y explique de donde procede el incre-mento del rendimiento.
2
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
3
2
Mux
0
1ALUOut
Memory
MemData
Writedata
Address
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signe
Shiftleft 2
PCMux
0
1
RegistersWriteregister
Writedata
Readdata 1
Readdata 2
Readregister 1
Readregister 2
Instruction[15– 11]
Mux
0
1
Mux
0
1
4
Instruction[15– 0]
Signextend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
Io
xtend
3216
Instruction[25– 21]
Instruction[20– 16]
Instruction[15– 0]
Instructionregister
ALUcontrol
ALUresult
ALUZero
Memorydata
register
A
B
IorD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instructi
rD
MemRead
MemWrite
MemtoReg
PCWriteCond
PCWrite
IRWrite
ALUOp
ALUSrcB
ALUSrcA
RegDst
PCSource
RegWrite
Control
Outputs
Op[5– 0]
Instruction[31-26]
Instruction [5– 0]
Mux
0
2
Jumpaddress [31-0]Instruction [25– 0] 26 28
Shiftleft 2
PC [31-28]
1
1 Mux
0
3
2
Mux
0
1ALUOut
Memory
MemData
Writedata
Address
Fig
ura
1:C
amin
od
ed
atos
3
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
='B
EQ')
(Op
='J
')
(Op
='SW
')
(Op
='L
W')
4
01
9862
753
Start
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1AL PCWrite
PCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchIn
USrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R
struction decode/register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
='B
EQ')
(Op
='J
')
(Op
='SW
')
(Op
='L
W')
4
01
9862
753
Start
Figura 2: Especificacion del control
4
C o n tro l A L U
A L U o p 1 A L U O p 0O p e ra c ió n
0 0 S u m a
0 1 R e s ta
1 0 F u n c . co d e
SR C 2
ALU S rB 1 A LU SrcB0O perac ión
0 0 B
0 1 4
1 0 E xtend
1 1 E xtS hft
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq.
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq.
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
S R C 1
A d d rS rc AO p e ra c ió n
0 P C
1 A
Figura 3: Campos y codificacion de los valores de las microinstrucciones
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
Src
A
ALU
Src
B1
ALU
Src
B0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sou
rce1
PC
Sou
rce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
Figura 4: Microprograma
5
Examen de TeorıaFundamentos de Computadores de Ingenierıa Informatica
Facultad de Informatica. Universidad de Las Palmas de GC14 de julio de 2004
1. (0.5 puntos) Disena el formato de las instrucciones de un maquina de registro-memoria que tiene las siguientes caracterısticas:
El repertorio de instrucciones contiene en total32 instrucciones, de lascuales16 son instrucciones del tipo:
• op Ry, (Rx); esto esRy ← Ry op M [Rx]
Otras8 instrucciones son del tipo:
• op Ry, Rx; esto esRy ← Ry op Rx
Y las otras8 restantes estan todavıa por especificar.
Solo admite para acceder a la memoria el modo de direccionamientoindirecto por registro.
Tiene un banco de8 registros.
En el formato de la instruccion se especifican3 campos: el primero,para el codigo de operacion; el segundo, para especificar el registroque es el segundo operando fuente o que contiene la direccion de me-moria del segundo operando fuente; y el tercero, para especificar elprimer registro fuente que es ademas siempre registro destino en lasinstrucciones especificadas.
2. (2.0 puntos) Para el repertorio de instrucciones del problema anterior:
(1.5 puntos) Disena una ruta de datos monociclo que soporte la ejecu-cion de las instrucciones especificadas. Explica claramente el nombrey la funcionalidad de cada una de las senales de control en el camino yel funcionamiento de cada uno de los bloques funcionales que utilices.
(0.5 puntos) Especifica la unidad de control para esa ruta de datosmediante una tabla de verdad o metodo equivalente.
3. (3 puntos) Las figuras 1 y 2 muestran la estructura y la especificacion delcontrol de la implementacion basica multiciclo del procesador MIPS R3000.
1
En esta implementacion tanto la instruccion de bifurcacion jump como lade salto condicionalbeq tardan3 ciclos en ser ejecutadas por el procesa-dor. Nuestro objetivo como disenadores de este procesador es considerar laimplementacion de estas dos instrucciones en dos ciclos.
a) (1.5 puntos) Anada los caminos de datos y las senales de control ne-cesarias al camino de datos multiciclo de la figura 1 para que ambasinstrucciones sean ejecutadas por el procesador en2 ciclos.
b) (1.5 puntos) Indique las modificaciones necesarias a la maquina deestados finitos de la figura 2 para que ambas intrucciones sean ejecu-tadas por el procesador en2 ciclos. Especifica claramente la maquinade estados finitos modificada.
4. (3 puntos) En nuestra companıa ademas de la version cableada del proce-sador basico MIPS R3000, tenemos tambien una version que implementael control mediante la tecnica de microprogramacion. Las figuras 3 y 4 re-sumen la especificacion del control mediante la tecnica de microprograma-cion.
a) (2 puntos) Realiza las modificaciones necesarias sobre las figuras 3 y4 para que ahora el control microprogramado funcione para el caminode datos modificado para que las instrucciones debifurcacion y saltofuncionen en2 ciclos. En el caso que algun cambio sea necesario,especifica los nuevos valores de las tablas deDispatch.
b) (1 punto) Codifica en binario o en hexadecimal las microinstruccionesque hayas modificado o anadido.
5. (1.5 puntos) Cabe esperar que las modificaciones del procesador MIPS R3000para que realice lossaltosy lasbifurcacionesen tan solo 2 ciclos disminu-ya la frecuencia de reloj del procesador. Por este motivo, antes de seguiradelante con nuestro procesador modificado, estamos interesados en saber:
a) (1 punto) ¿Cual es la frecuencia mınima (en relacion con la frecuenciaactualfactual a partir de la cual deja de ser interesante el cambio queproponemos?
b) (0.5 puntos) ¿Cual es la frecuencia mınima necesaria para una frecuen-cia original de 100MHz?
2
Tipo Frecuencia ( %)Tipo-R 41Load 24Store 14Saltos y bifurcaciones 21
Cuadro 1: Frecuencia simplificada de usos de las instrucciones para el programagcc
Para realizar el calculo de esta frecuencia mınima, al menos de manera apro-ximada, disponemos de los datos de la mezcla de instrucciones del progra-magccen la tabla 1.
3
Shi
ftle
ft2
PC
M u x0 1
Reg
iste
rsW
rite
reg
iste
r
Writ
ed
ata
Rea
dda
ta1
Rea
dda
ta2
Re
ad
reg
iste
r1
Re
ad
reg
iste
r2
Inst
ruct
ion
[15–
11]
M u x0 1
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sig
nex
ten
d
32
16
Inst
ruct
ion
[25
–21
]
Inst
ruct
ion
[20
–16
]
Inst
ruct
ion
[15
–0]
Inst
ruct
ion
reg
iste
r
ALU
con
tro
l
ALU
resu
ltA
LUZ
ero
Mem
ory
da
tare
gis
ter
A B
IorD
Me
mR
ea
d
Me
mW
rite
Me
mto
Reg
PC
Writ
eCo
nd
PC
Writ
e
IRW
rite
ALU
Op
AL
US
rcB
AL
US
rcA
Reg
Dst
PC
So
urce
Re
gW
rite
Co
ntro
l
Ou
tpu
ts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0
]2
628
Sh
iftle
ft2
PC
[31
-28
]
1
1M u x
0 32
M u x0 1A
LUO
ut
Mem
ory
Mem
Dat
a
Wri
teda
ta
Ad
dres
s
Shi
ftle
ft2
PC
M u x0 1
Reg
iste
rsW
rite
reg
iste
r
Writ
ed
ata
Rea
dda
ta1
Rea
dda
ta2
Re
ad
reg
iste
r1
Re
ad
reg
iste
r2
Inst
ruct
ion
[15–
11]
M u x0 1
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sig
ne
Shi
ftle
ft2
PC
M u x0 1
Reg
iste
rsW
rite
reg
iste
r
Writ
ed
ata
Rea
dda
ta1
Rea
dda
ta2
Re
ad
reg
iste
r1
Re
ad
reg
iste
r2
Inst
ruct
ion
[15–
11]
M u x0 1
M u x0 1
4
Inst
ruct
ion
[15–
0]
Sig
nex
ten
d
32
16
Inst
ruct
ion
[25
–21
]
Inst
ruct
ion
[20
–16
]
Inst
ruct
ion
[15
–0]
Inst
ruct
ion
reg
iste
r
ALU
con
tro
l
ALU
resu
ltA
LUZ
ero
Mem
ory
da
tare
gis
ter
A B
Io
xten
d
32
16
Inst
ruct
ion
[25
–21
]
Inst
ruct
ion
[20
–16
]
Inst
ruct
ion
[15
–0]
Inst
ruct
ion
reg
iste
r
ALU
con
tro
l
ALU
resu
ltA
LUZ
ero
Mem
ory
da
tare
gis
ter
A B
IorD
Me
mR
ea
d
Me
mW
rite
Me
mto
Reg
PC
Writ
eCo
nd
PC
Writ
e
IRW
rite
ALU
Op
AL
US
rcB
AL
US
rcA
Reg
Dst
PC
So
urce
Re
gW
rite
Co
ntro
l
Ou
tpu
ts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
cti
rD
Me
mR
ea
d
Me
mW
rite
Me
mto
Reg
PC
Writ
eCo
nd
PC
Writ
e
IRW
rite
ALU
Op
AL
US
rcB
AL
US
rcA
Reg
Dst
PC
So
urce
Re
gW
rite
Co
ntro
l
Ou
tpu
ts
Op
[5–
0]
Inst
ruct
ion
[31-
26]
Inst
ruct
ion
[5–
0]
M u x
0 2
Jum
pad
dre
ss[3
1-0
]In
stru
ctio
n[2
5–0
]2
628
Sh
iftle
ft2
PC
[31
-28
]
1
1M u x
0 32
M u x0 1A
LUO
ut
Mem
ory
Mem
Dat
a
Wri
teda
ta
Ad
dres
s
Figura 1: Camino de datos
4
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
='B
EQ')
(Op
='J
')
(Op
='SW
')
(Op
='L
W')
4
01
9862
753
Start
PCWritePCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1AL PCWrite
PCSource = 10
ALUSrcA = 1ALUSrcB = 00ALUOp = 01PCWriteCond
PCSource = 01
ALUSrcA =1ALUSrcB = 00
ALUOp= 10
RegDst = 1RegWrite
MemtoReg = 0
MemWriteIorD = 1
MemReadIorD = 1
ALUSrcA = 1ALUSrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchIn
USrcB = 10ALUOp = 00
RegDst=0RegWrite
MemtoReg= 1
ALUSrcA = 0ALUSrcB = 11ALUOp = 00
MemReadALUSrcA = 0
IorD = 0IRWrite
ALUSrcB = 01ALUOp = 00
PCWritePCSource = 00
Instruction fetchInstruction decode/
register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R
struction decode/register fetch
Jumpcompletion
BranchcompletionExecution
Memory addresscomputation
Memoryaccess
Memoryaccess R-type completion
Write-back step
(Op = 'LW') or (Op = 'SW') (Op = R-type)
(Op
='B
EQ')
(Op
='J
')
(Op
='SW
')
(Op
='L
W')
4
01
9862
753
Start
Figura 2: Especificacion del control
5
C o n tro l A L U
A L U o p 1 A L U O p 0O p e ra c ió n
0 0 S u m a
0 1 R e s ta
1 0 F u n c . co d e
SR C 2
ALU S rB 1 A LU SrcB0O perac ión
0 0 B
0 1 4
1 0 E xtend
1 1 E xtS hft
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq.
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
Control PCWrite
PCSrc1 PcSrc0 PCwrite PCWrtCondOper.
0 0 1 0 ALU
0 1 0 1 ALUOut-Cond
1 0 1 0 Jump address
S ec
A ddrC tl1 A ddrC tl0O perac ión
1 1 S eq.
0 0 Fetch
0 1 D ispatch1
1 0 D ispatch2
S R C 1
A d d rS rc AO p e ra c ió n
0 P C
1 A
Figura 3: Campos y codificacion de los valores de las microinstrucciones
Estado Etiqueta ControlALU
SRC1 SRC2 ControlRegistros
Memoria ControlPCWrite
Secuenc.
0 Fetch Add PC 4 Read PC ALU Seq.1 Add PC Extshft Read Dispatch 12 Mem1 Add A Extend Dispatch 23 LW2 Read ALU Seq4 Write MDR Fetch5 SW2 Write ALU Fetch6 Rformat1 Func
CodA B Seq
7 Write ALU Fetch8 BEQ1 Subt A B ALUOut-
condFetch
9 JUMP1 JumpAddress
Fetch
Control ALU SRC1 SRC2 ControlRegistro Memoria Control PCWrite Sec.
Alu
op1
Alu
op0
Alu
Src
A
ALU
Src
B1
ALU
Src
B0
Reg
Writ
e
Reg
Dst
Mem
ToR
eg
IRW
rite
Mem
Rea
d
IorD
Mem
Writ
e
PC
Sou
rce1
PC
Sou
rce0
PC
Writ
e
PC
Writ
eCon
d
Add
rCtl1
Add
rCtl0
Figura 4: Microprograma
6
Examen de PracticasFundamentos de Computadores de Ingenierıa Informatica
Facultad de Informatica. Universidad de Las Palmas de GC14 de julio de 2004
Las figuras 1, 2 y 3, muestran parte del estado en un instante determinado de una maquinaMIPS R2000. La figura 1 muestra el valor de los registros, la figura 2 indica el contenido de lamemoria y la figura 3 corresponde al segmento de texto.
1. (5 puntos) Escribe el codigo en ensamblador de la secuencia de instrucciones ejecutadas des-de el estado actual hasta que el registro contador de programaPC toma el valor 0x0040009C.Utiliza si lo consideras conveniente la tabla de codigos de operacion 1
2. (2.5 puntos) ¿Cual es el contenido de los registros despues de que el registroPC tome elvalor 0x0040009C?
3. (2.5 puntos) ¿Cual es el contenido de la memoria despues de que el registroPC tome elvalor 0x0040009C?
nemonico cod-op. nemonico cod-op. campo funcionlw rt, rs, inmediato 0x23 sw rt, rs, inmediato 0x2Bori rt, rs, inmediato 0x0D addu rd, rs, rt 0 0x21addiu rt, rs, inmediato 0x09 mult rt, rs 0 0x18slti rt, rs, inmediato 0x0A slt rd, rs, rt 0 0x2Abne rs, rt, inmdiato 0x05 bgez rs, inmediato 0x01
jr rs 0 8
Cuadro 1: Tabla de codigos de operacion
Figura 1: Contenido de los registros
1
Figura 2: Contenido del segmento de datos
Figura 3: Lenguaje maquina de un procedimiento
2
Examen Fundamentos de Computadores de la IngenierıaInformatica
Facultad de Informatica. Universidad de Las Palmas de GranCanaria
12 de diciembre de 2003
1. (2.5 puntos) Para un computador de longitud de palabra de36 bits, disena(razonablemente) los formatos de las instrucciones para que permitan cons-truir un repertorio de instrucciones con:
7 instrucciones con dos direcciones de15 bits y una de3 bits.
500 instrucciones con una direccion de15 bits y una de3 bits
50 instrucciones con0 direcciones.
2. (2.5 puntos) Se esta interesado en2 realizaciones de una maquina, una conuna circuiterıa especial de punto flotante y otra sin ella. Considerese unprogramaP , con la siguiente mezcla de operaciones:
multiplicacion en punto flotante 10 %suma en punto flotante 15 %division en punto flotante 5 %instrucciones de enteros 70 %
La maquina MPF (maquina con punto flotante) tiene circuiterıa de puntoflotante y puede por lo tanto realizar operaciones de punto flotante directa-mente. Se requiere el siguiente numero de ciclos de reloj para cada tipo deinstruccion:
multiplicacion en punto flotante 6suma en punto flotante 4division en punto flotante 20instrucciones de enteros 2
La maquina MSPF (maquina sin punto flotante) no tiene circuiterıa de puntoflotante y por lo tanto debe emular las operaciones de punto flotante usandoinstrucciones de enteros. Las instrucciones de enteros necesitan todas dosciclos de reloj. El numero de INSTRUCCIONES de enteros necesarias pararealizar cada operacion de punto flotante es el siguiente:
1
multiplicacion en punto flotante 30suma en punto flotante 20division en punto flotante 50
Ambas maquinas tienen una frecuencia de reloj de100MHz.
a) Calcula la tasa de MIPS (millones de instrucciones por segundo) paraambas maquinas.
b) Si la maquina MPF necesita300 millones de instrucciones para un pro-grama, ¿cuantas instrucciones de enteros requerira la maquina MSPFpara el mismo programa?
c) ¿Cual es el tiempo de ejecucion para dicho programa de300 millonesde instrucciones en la maquina MPF y MSPF?
3. (2.5 puntos) Escribe un programa en ensamblador MIPS que inicialice unvector de palabras con la constante0. Asume que la direccion de comienzodel vector esta en el registroa0 y el tamano del vector de palabras esta en elregistroa1.
4. (2.5 puntos) Se quiere anadir la instruccion jm (jump memory, salto a me-moria) al camino de datos multiciclo. Su formato de instruccion es igualal de lw excepto que el camport no se utiliza porque el dato cargado dememoria se coloca en elPC en vez de hacerlo en registro destino.
a) Anada los caminos de datos y las senales de control necesarias al ca-mino de datos multiciclo.
b) Indica las modificaciones necesarias a la maquina de estados finitos.Especifica claramente cuantos ciclos necesita la nueva instruccion pa-ra ejecutarse en su camino de datos y la maquina de estados finitosmodificada.
2
Figura 1: Camino de datos multiciclo.
3
Figura 2: Especificacion del control para la ruta de datos multiciclo.
4
Convocatoria extraordinaria de septiembre (septiembre 2003). Examen deFCI. Duracion 2 horas.
1. (1 punto) Utilizando reiteradamente las leyes de Morgan, obtener unaexpresion en forma de suma de productos para las siguientes funciones:
a) F = (x + y)(xy + z)
b) G = (xy + xz) (x + yz)
2. (1 punto) Obtener una expresion como suma de minterms y otra comoproducto de maxterms para la siguiente funcion:
f(x, y, z) = xy + xz + yz
3. (1 punto) Dada la siguiente funcion como suma de minterms, pasarla aproducto de maxterms. Minimizar la expresion resultante de la funcionempleando maxterms.
f(x, y, z, w) =∑
m(0, 2, 3, 4, 5, 6, 11)
4. (2 puntos) Obtener el resultado de las siguientes operaciones binarias:
a) 110101 + 1001001
b) 1110010110− 101011001
c) 0,01001× 101,1001
d) 1011,001/0,1101
5. (2.5 puntos) Minimizar la tabla de estado utilizando uno de los dosmetodos estudiados.
0 1 2 3A B,1 A,1 E,0 D,0B F,1 C,0 E,1 A,1C I,1 B,0 F,1 I,1D F,1 B,0 I,1 A,1E H,0 A,1 I,1 F,0F B,0 A,1 I,1 F,0G B,1 A,1 F,0 I,0H E,1 C,0 F,1 A,1I B,0 A,1 G,1 I,0
1
6. (2.5 puntos) Disena con biestables tipo D un sistema secuencial sıncronocon dos entradas, E y C, y dos salidas, Z y S. Si durante tres pulsos dereloj se mantiene C=1, entonces Z = E y S = 1; si durante tres pulsosde reloj se mantiene C = 0, entonces Z = E y S = 1; en cualquier otrocaso ha de ser Z = 0 y S = 0.
2
Examen Fundamentos de Computadores de la Ingenierıa InformaticaFacultad de Informatica. Universidad de Las Palmas de Gran Canaria
Septiembre de 2003
1. (2.5 puntos) Comparar las maquinas de 0, 1 y 2 direcciones, escribiendo progra-mas para calcular la expresion:
X = (A + B · C)/(D − E · F −G ·H)
Para cada una de los tres tipos de maquinas el repertorio de instrucciones dispo-nibles es el siguiente:
0 direcciones 1 direcciones 2 direccionesPUSH M LOAD M MOVE X, YPOP M STORE M SUM X, YSUM SUM M RES X, YSUB SUB M MUL X, YMUL MUL M DIV X, YDIV DIV M
donde M es una direccion de memoria de 16 bits y X e Y son direcciones de 16bits o numeros de registros de 4 bits.
La maquina de 0 direcciones usa una pila, la de 1 direccion usa un acumulador yla de dos direcciones tiene 16 registros e instrucciones en las que cada operandopuede estar en un registro o en memoria. Suponiendo codigos de operacion de8 bits y longitudes de instruccion que son multiplos de 4 bits. ¿Cuantos bitsnecesita cada computadora para representar el programa que calcula el valor deX?
2. (2.0 puntos) Asuma la personalidad del disenador jefe de un nuevo procesador.El diseno del procesador y el compilador estan completados, y ahora se debedecidir si se fabrica el diseno actual tal y como esta o se utiliza tiempo adicionalpara mejorarlo. Se discute el problema con el grupo de ingenierıa de circuitos yse llega a las siguientes opciones:
Dejar el diseno tal y como esta. A esta maquina base se le da el nombrede Mbase. Tiene una frecuencia de reloj de 500MHz y se han tomado lassiguientes medidas usando un simulador:
Tipo de instruccion CPI FrecuenciaA 2 40 %B 3 25 %C 3 25 %D 5 10 %
Optimizar la circuiterıa. El grupo de ingenierıa de circuitos indica que pue-de mejorar el diseno del procesador para dar una frecuencia de 600MHz.A esta maquina se le da el nombre Mopt. Se han tomado las siguientesmedidas usando un simulador para Mopt:
1
Tipo de instruccion CPI FrecuenciaA 2 40 %B 3 25 %C 3 25 %D 4 10 %
a) ¿Cual es el CPI para cada maquina? (0.5 puntos)
b) ¿Cuales son las tasas de MIPS originales para Mbase y Mopt? (0.5 puntos)
c) ¿Cuanto mas rapida es Mopt que Mbase? (1.0 puntos)
3. (1.5 puntos) El procedimientostrcpy copia la cadenay en la cadenaxusando la convencion de C de terminacion con byte nulo:
void strcpy( char x[ ] , char y[ ] )
{
int i;
i = 0;
while ( ( x[ i] =y[ i] ) ! =0) /* copia y comprueba el byte */
i = i+1;
}
4. (1.5 puntos) Se quiere anadir la instruccion jm (jump memory o salto a memo-ria) al camino de datos multiciclo. El formato de la nueva instruccion es igualal de la instruccion lw excepto que el camport no se utiliza porque el da-to cardado de memoria se coloca en el PC en lugar de escribirlo en el registrodestino. Anada los caminos de datos y las senales de control necesarias al cami-no de datos multiciclo de la figura 1, e indique las modificaciones necesarias ala maquina de estados finitos de la figura 2. Intente encontrar una solucion queminimice el numero de ciclos de reloj requeridos para la nueva instruccion. es-pecifique claramente cuantos ciclos necesita la nueva instruccion para ejecutarseen el camino de datos con la maquina de estados finitos modificados.
5. (2.5 puntos) Anada los caminos de datos y las senales de control necesarias alcamino de datos multiciclo de la figura 1 y las modificaciones del diagrama deestados de la figura 2 para gestionar las excepciones debidas a instrucciones nodefinidas o desbordamientos aritmeticos. Explica tambien como el procesadortrata una excepcion.
2
Figura 1: Camino de datos multiciclo.
3
Figura 2: Especificacion del control para la ruta de datos multiciclo.
4
Examen Fundamentos de Computadores de la Ingenierıa InformaticaFacultad de Informatica. Universidad de Las Palmas de Gran Canaria
14 de julio de 2003
P1 P2 P3 P4 P51.75 2.5 1 1.75 3
1. 1.75 puntos. Un computador tiene palabras de24 bits. Los operandos se pueden direccionarde las formas siguientes:
Registro (R): se requieren4 bits.
Memoria (M): se requieren4 bits para el registro base y9 para el desplazamiento
Inmediato (I):9 bits.
a) Disenar los formatos de instrucciones necesarios para tener un repertorio con2 instruc-ciones de M-I,63 instrucciones de M-R,15 instrucciones de R-I y64 instrucciones deR-R.
b) ¿Variaran los formatos disenados en el apartado anterior si en las especificaciones delmismo repertorio de instrucciones nos piden14 instrucciones de R-I en vez de15?
2. 2.5 puntos. Considere el siguiente fragmento de codigo C:
for ( i=0; i<=1000; i=i+1) { a[ i] = b[ i] + c}
Suponga quea y b son vectores de palabras y la direccion base dea esta en el registro$a0 y la de b en $a1 . El registro $t0 se asocia con la variablei y $s0 con lavariable c . Escriba el codigo MIPS. ¿Cuantas instrucciones se ejecutan a lo largo de estecodigo? ¿Cuantas referencias de datos a memoria se produciran durante la ejecucion?
3. 1.0 punto. El codigo siguiente trata de implementar un salto condicional a la direccion no-es-cero, cuyo valor es 0xABCD1234. Sin embargo, dicho salto no funciona de la forma queesta implementado. Explique por que e indique de que manera habrıa que codificarlo paraque funcione.
0x00000004 add $8, $15, $160x00000008 bne $8, $0, no-es-cero
...no-es-cero: sub $9, $12, $13
1
Tipo Frecuencia ( %)Tipo-R 41Load 24Store 14Saltos y bifurcaciones 21
Cuadro 1: Frecuencia simplificada de usos de las instrucciones para el programa gcc
4. 1.75 puntos. Sus amigos de laC3 (Creative Computer Corporation) han determinado queel camino crıtico que establece la longitud del ciclo de reloj del camino de datos multici-clo es el acceso a memoria para la carga o almacenamiento de datos (no para la busquedade instrucciones) Esto ha dado lugar a su mas reciente realizacion de la MIPS 30000 paraejecutar con una frecuencia de 500MHz en vez del objetivo de alcanzar los 750MHz. Detodas formas, Beatriz e Ibrahin, deC3, tienen una solucion. Si todos los ciclos que accedena memoria para datos se dividen en dos ciclos, entonces la maquina puede funcionar con lafrecuencia de reloj final. Utilizando la combinacion de instrucciones del gcc mostrada en latabla 1, determine cuanto mas rapida sera la maquina con accesos a memoria de dos ciclosrespecto a la maquina de 500MHz con acceso a memoria en un solo ciclo. Suponga quetodos los saltos necesitan el mismo numero de ciclos y que las instrucciones del repertorio ylas aritmeticas inmediatas se realizan como de tipo R.
5. 3.0 puntos. Se quiere anadir la la instruccion aritmetica de4 operandosadd3, la cualsuma tres numeros en vez de dos:
add3 $t5, $t6, $t7, $t8 # $t5 = $t6 + $t7 + $t8
Anada los caminos de datos y las senales de control necesarias al camino de datosmulticiclo de la figura 1, e indique las modificaciones necesarias a la maquina de estadosfinitos de la figura 2. Especifique claramente cuantos ciclos necesita la nueva instruccionpara ejecutarse en su camino de datos y la maquina de estados finitos modificada. Supongaque la arquitectura del repertorio de instrucciones esta modificada con un nuevo formatode instruccion similar al formato R, excepto que los bits 0-4 se utilizan para especificar elregistro adicional (se seguira utilizando los rs, rt y rd) y, por supuesto, se utiliza un nuevocodigo de operacion. Su solucion no deberıa depender de anadir nuevos puertos de lectura albanco de registro, ni deberıa utilizar una nueva ALU.
2
Figura 1: Camino de datos para el problema 5.
3
Figura 2: Especificacion del control para el problema 5.
4