Problemas de Fundamentos y Estr - Alfredo Cuesta Infante

Por otro lado, una vez explicada y estudiada la teoría, el libro es además una herramienta de autoevaluación. En este sentido, desde nuestra experiencia, recomendamos al lector que no mire las soluciones, sino que previamente se enfrente al problema e intente resolverlo por cuenta propia, acudiendo como último recurso al breve apunte teórico que hay al comienzo de cada capítulo. El libro recopila más de 250 problemas resueltos y otros tantos solamente enunciados. La mayor parte de ellos han sido propuestos en exámenes de Diplomatura y Licenciatura en Informática a lo largo de los 10 últimos años. Los temas que abarca se pueden agrupar en las siguientes materias: • Representación de la información • Diseño Combinacional • Diseño Secuencial • Diseño Algorítmico • Ensamblador • Modos de direccionamiento • Formato de instrucciones • Ruta de datos y Unidad de Control • Memoria • Buses • Entrada/Salida • Segmentación • Rendimiento

Problemas de fundamentos y estructura de computadores

Este libro pretende ser un complemento práctico a la extensa bibliografía teórica en el área de Diseño Lógico, Estructura y Arquitectura de Computadores. En estas asignaturas el alumno se enfrenta a un gran número de métodos y conceptos, que naturalmente debe aprender, pero cuya finalidad es ser aplicados en problemas reales. Por ello creemos que disponer de una colección de casos prácticos, presentados en forma de ejercicios, puede aclarar los conceptos que se están estudiando en estas asignaturas.


Cuesta Hidalgo Lanchares Risco ISBN 978-84-8322-591-2

9 788483 225912

www.pearsoneducacion.com

Problemas de fundamentos.indd 1

Alfredo Cuesta Infante José Ignacio Hidalgo Pérez Juan Lanchares Dávila José Luis Risco Martín 20/7/11 13:25:07


a

Problemas de fundamentos y estructura de computadores Alfredo Cuesta infante Profesor Contratado Centro de Estudios Superiores Felipe II Universidad Complutense de Madrid

José Ignacio Hidalgo Pérez Profesor Titular de Universidad Facultad de Informática Universidad Complutense de Madrid

Juan Lanchares Dávila Profesor Titular de Universidad Facultad de Informática Universidad Complutense de Madrid

José Luis Risco Martín Profesor Contratado Doctor Facultad de Informática Universidad Complutense de Madrid

Madrid México Santafé de Bogotá Buenos Aires Caracas Lima Montevideo San Juan San José Santiago Sa˜o Paulo Reading, Massachusetts Harlow, England

Datos de catalogación bibliográfica

PROBLEMAS DE FUNDAMENTOS Y ESTRUCTURA DE COMPUTADORES Alfredo C. Infante, José I. Hidalgo Pérez, Juan Lanchares Dávila, José L. Risco Martín PEARSON EDUCACIÓN, S.A., 2009 ISBN: 978-84-8322-591-2 Materia: 004, Computadores Formato 195#250 mm.

Páginas: 568

Todos los derechos reservados. Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra sólo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. La infracción de los derechos mencionados puede ser constitutiva de delito contra la propiedad intelectual (arts. 270 y sgts. Código penal). Diríjase a CEDRO (Centro Español de Derechos Reprográficos: www.cedro.org), si necesita fotocopiar o escanear algún fragmento de esta obra. 5 PEARSON EDUCACIÓN, S.A., 2009 Ribera del Loira, 28 28042 Madrid (España) www.pearsoneducacion.com ISBN: 978-84-8322-591-2 Depósito legal: Equipo editorial: Editor: Miguel Martín-Romo Técnico editorial: Esther Martín Equipo de producción: Director: José Antonio Clares Técnico: Isabel Muñoz Diseño de cubierta: Equipo de diseño de Pearson Educación, S.A. Composición COPIBOOK, S.L. Impreso por: Nota sobre enlaces a páginas web ajenas: Este libro puede incluir enlaces a sitios web gestionados por terceros y ajenos a PEARSON EDUCACIÓN, S.A. que se incluyen sólo con finalidad informativa. PEARSON EDUCACIÓN, S.A. no asume ningún tipo de responsabilidad por los daños y perjuicios derivados del uso de los datos personales que pueda hacer un tercero encargado del mantenimiento de las páginas web ajenas a PEARSON EDUCACIÓN, S.A. y del funcionamiento, accesibilidad o mantenimiento de los sitios web no gestionados por PEARSON EDUCACIÓN, S.A. Las referencias se proporcionan en el estado en que se encuentran en el momento de publicación sin garantías, expresas o implícitas, sobre la información que se proporcione en ellas. Impreso en España - Printed in Spain Este libro ha sido impreso con papel y tintas ecológicos

A mis padres. A. Cuesta

A Esther, Elena y Julia que dan alegría y sentido a mi vida. J. I. Hidalgo

A Paloma y Juan: empezar todos los días riendo es lo mejor que te puede ocurrir, y gracias a ellos yo lo consigo. J. Lanchares

A mi hijo Jaime. Y, naturalmente, a mi mujer Esther, porque les quiero y son lo más importante para mí. J. L. Risco

a

Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

xi

Capítulo 1 Representación de la información . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1

1.1 Sistema de numeración binario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Cambios de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1 2

1.2.1 Sustitución en serie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.2 Multiplicación y división . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2.3 Cuando una base es potencia de la otra (R % Sx o S % Rx) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

2 2 3

1.3 Representación de números enteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3

1.3.1 1.3.2 1.3.3 1.3.4

Magnitud y Signo (MyS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Complemento a 2 (C2) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Complemento a 1 (C1) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Código BCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

3 4 4 5

1.4 Representación de números en coma flotante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5 Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6 Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

5 7 22

Capítulo 2 Sistemas combinacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

25

2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 2.10 2.11 2.12

Especificación mediante Funciones de Conmutación (F.C.) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Especificación mediante Expresiones de Conmutación (E.C.) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Simplificación mediante mapas de Karnaugh . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementación de sumas de productos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Análisis de sistemas combinacionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Conjuntos universales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Descodificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Multiplexores o selectores (MUX) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ROMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Otros módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

25 25 27 27 28 29 30 30 32 33 33 71

viii

Introducción

Capítulo 3 Sistemas secuenciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

77

3.1 Definición de sistema secuencial y concepto de estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

77

3.1.1 Sistema secuencial (Definición formal) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.2 Concepto de estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

77 77

3.2 Clasificación de sistemas secuenciales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 Sistemas síncronos y asíncronos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

78 78

3.3 Especificación binaria. Obtención de diagramas de estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

78

3.3.1 Reconocedores de secuencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.2 Contadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

78 80

3.4 Implementación no canónica de reconocedores con biestables D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.5 Implementación canónica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6 Módulos secuenciales estándar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.1 Registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.2 Registros de desplazamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.3 Banco de registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.4 Contadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.7 Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.8 Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

80 81 81 81 82 82 83 84 115

Capítulo 4 Introducción al diseño algorítmico de sistemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

119

4.1 4.2 4.3 4.4

Esquema general de un sistema diseñado algorítmicamente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Proceso de diseño . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

119 121 121 175

Capítulo 5 Estructura de un computador sencillo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

179

5.1 5.2 5.3 5.4 5.5 5.6

Diseño de la unidad de proceso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diseño de la ALU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Formato de las instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diseño de la unidad de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

179 181 182 183 185 224

Capítulo 6 Introducción a la programación en lenguaje ensamblador . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

229

6.1 6.2 6.3 6.4 6.5 6.6 6.7

Instrucciones aritmético-lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instrucciones de acceso a memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Instrucciones de salto (BCC) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Directivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diagramas de flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

230 230 230 231 231 232 264

Capítulo 7 Rendimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

267

7.1 Definiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7.2 Medidas de rendimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

267 268

Introducción

7.3 7.4 7.5 7.6 7.7

ix

MIPS: Millones de instrucciones por segundo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . MFLOPS: Millones de instrucciones en coma flotante por segundo . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ley de AMDAHL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

268 269 269 270 289

Capítulo 8 Modos de direccionamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

293

8.1 8.2 8.3 8.4 8.5 8.6

Direccionamiento inmediato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Direccionamiento directo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Direccionamiento relativo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Direccionamiento indirecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

293 294 295 298 299 312

Capítulo 9 Teoría del formato de instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

317

9.1 9.2 9.3 9.4

Campos de la instrucción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Características del conjunto de formatos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

318 319 320 348

Capítulo 10 Diseño del camino de datos y la unidad de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

353

10.1 Partes básicas de un procesador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.1 Los registros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.2 La memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.3 Unidad aritmético-lógica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.4 Estudio y diseño del camino de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.1.5 La unidad de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.2 Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10.3 Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

353 353 355 355 356 357 358 386

Capítulo 11 Procesadores segmentados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

389

11.1 11.2 11.3 11.4 11.5

Segmentación básica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas y soluciones: técnicas básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pipeline multifuncional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

390 391 394 396 425

Capítulo 12 Memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

431

12.1 12.2 12.3 12.4 12.5

Propiedades de la jerarquía de memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La memoria cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Memoria virtual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

432 433 436 438 478

Capítulo 13 Entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

483

13.1 Bus de direcciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

484

x

Introducción

13.2 Módulos de E/S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3 Gestión de la comunicación CPU-periféricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.1 Selección del periférico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.2 Gestión de las señales de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.3.3 Sincronización con la CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.4 E/S programada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5 E/S mediante interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.1 Petición de interrupción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.2 Reconocimiento de interrupción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.3 Identificación del dispositivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.5.4 Prioridades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.6 E/S DMA (Direct Memory Access) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.7 Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13.8 Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

484 484 485 485 485 485 486 486 486 487 487 487 488 515

Capítulo 14 Buses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

519

14.1 14.2 14.3 14.4

Estructura del bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Uso básico del bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clases de buses y jerarquías . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Diseño del bus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.1 Temporización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.2 Tipos de transferencia de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.3 Esquemas de arbitraje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.4.4 Decisiones de diseño . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.5 Problemas resueltos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14.6 Problemas propuestos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

520 520 521 522 522 524 524 525 525 546

Bibliografía . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

551

Aunque existen bastantes textos teóricos sobre Fundamentos y Estructura de Computadores, es difícil encontrar una recopilación de problemas resueltos sobre esta materia. Con la llegada de los nuevos títulos de grado y la implantación del Espacio Europeo de Educación Superior, el trabajo práctico en clase y su extensión a las horas de estudio se hace cada vez más importante. Para que el alumno pueda afianzar sus conocimientos, sin duda, la mejor metodología es la realización de supuestos prácticos y para realizarlos se hacen necesarias herramientas como el libro que aquí presentamos. Problemas de Fundamentos y Estructura de Computadores pretende ofrecer al lector una amplia variedad de problemas resueltos que cubran los aspectos más importantes de las asignaturas de Fundamentos y Estructura de Computadores, desde el diseño secuencial y combinacional hasta los procesadores segmentados. El libro está dividido en dos partes claramente diferenciadas y que responden a su propio título. Los primeros 6 capítulos se dedican a lo que generalmente se conoce como Fundamentos de Computadores y en la segunda parte, capítulos 8 a 14, se avanza en temas algo más complejos relacionados con la Estructura de Computadores, de tal forma que el texto profundiza en complejidad de forma gradual. Los capítulos están organizados en tres partes. En primer lugar se realiza una breve introducción teórica que recuerda los conceptos más importantes. A continuación se exponen un conjunto de problemas resueltos (en torno a 20 por capítulo) y se concluye con una serie de problemas propuestos. En el Capítulo 1 se trata el tema de representación de la información. Este libro cubre una gran parte los conceptos estudiados en las asignaturas dedicadas al diseño, análisis e implementación de sistemas de computación. Entenderemos por sistema un dispositivo que recibe, procesa y genera información en un tiempo finito. Conocer el modo en el que se representa la información es por tanto un pilar esencial pues en esa codificación arranca el resto de procedimientos que se estudiarán. La información, una vez codificada, se transformará en un número binario. Es por tanto natural comenzar por decidir el modo en el que se representarán los números enteros y reales utilizando un sistema de numeración binaria. En el libro se resuelven y proponen ejercicios de cambios de base, notación Magnitud y Signo (MyS), C1 y C2, así como de representación en coma flotante y el standard IEEE 754.

xii

Introducción

Los primeros sistemas de cómputo que se deben estudiar son los que se tratan en el Capítulo 2 y son los denominados combinacionales. Los motivos son varios. En primer lugar este tipo de sistemas no necesita ningún elemento de memoria complejo y la salida depende exclusivamente de los últimos valores recibidos en la entrada. El lector comenzará a trabajar con la operación aritmética más básica como sumar, o las operaciones lógicas AND, OR y NOT que son esenciales en aritmética binaria. En segundo lugar, son precisamente los sistemas que implementan estas operaciones lógicas los que, agrupados en módulos que gradualmente van creciendo en tamaño, dan lugar a sistemas más complejos. Los problemas de este capítulo tratan conceptos como el de conjunto universal, el uso de módulos e incide especialmente en la correcta codificación de un problema con enunciados contextualizados, es decir, tal y como se podrían plantear en la vida real. Una vez vistos los conceptos iniciales de diseño lógico de sistemas combinacionales, en el Capítulo 3 se tratan los sistemas secuenciales, que son aquellos que incorporan elementos de memoria o de almacenamiento de la información. De este modo, la salida en un instante dado depende, no sólo de la entrada del sistema en el momento de proporcionar la salida, sino también de los valores recibidos hasta ese momento. Puesto que es imposible almacenar toda la información recibida desde el comienzo, es imprescindible comprender el concepto de Estado y de Máquina de estados. Por otro lado, es necesario también estudiar los diferentes módulos secuenciales que, junto con las máquinas de estados y los módulos combinacionales, sentarán las bases del diseño de sistemas complejos capaces de resolver algoritmos y finalmente de implementar computadores. En el Capítulo 4 se aborda el diseño algorítmico de sistemas digitales. Una vez que el lector se ha afianzado en el manejo de los sistemas combinacionales y secuenciales es el momento de pasar a diseñar sistemas procesadores sencillos. Cualquier sistema se puede ver como un pequeño procesador compuesto por una Unidad de Proceso y una Unidad de Control. El diseño algorítmico nos permite obtener la implementación de un sistema atendiendo a este esquema. El Capítulo 5 amplía los conceptos de Unidad de Control y Unidad de Proceso para estudiar las características de un sistema computador sencillo pero completo y sus modificaciones: Partiendo de unas especificaciones estándar, la máquina rudimentaria, se resuelven problemas sobre cambios en el formato de instrucciones, la ruta de datos y la unidad de control. Con este capítulo el lector obtiene una primera aproximación a la estructura de un computador. La máquina Rudimentaria se describe y explica en profundidad en (Hermida et al. 2000). El lenguaje ensamblador permite programar directamente las máquinas que se han diseñado en los dos capítulos anteriores. En este momento el lector ya tiene una idea clara de cómo la máquina procesa las instrucciones codificadas en binario que incluyen información de control y los operandos del procesador. Para evitar que el programador tenga que utilizar ese lenguaje tedioso de 0’s y 1’s, se utiliza un lenguaje nemotécnico conocido como lenguaje ensablador y que utiliza expresiones similares al lenguaje natural para especificar las instrucciones. El Capítulo 6 presenta una serie de problemas relativos a la programación en ensamblador. El objetivo principal no es que el alumno realice programas muy complejos, sino que obtenga una visión clara de la forma en que se deben manejar los registros y la información una vez que ha diseñado y modificado máquinas de procesamiento básicas. El simulador de la Máquina Rudimentaria está disponible en ftp://ftp.ac.upc.es/.

Introducción

xiii

En el Capítulo 7 se tratan los aspectos de cómo medir el coste y rendimiento de un computador. Al diseñar un computador o al mejorar un subsistema de alguno existente, el arquitecto de computadores debe tener en cuenta los objetivos de la máquina a modificar teniendo presentes estos dos importantes parámetros. El Capítulo 8 recoge una serie de problemas de modos de direccionamiento y pretende que el lector conozca la flexibilidad que los modos de direccionamiento dan al programador a la hora de acceder a los datos almacenados en la memoria. Este capítulo tiene continuidad en el Capítulo 9, dedicado a los formatos de las instrucciones, y 10, sobre diseño de camino de datos. En el de formatos porque en él se ve cómo el número y modos de direccionamientos afecta al formato final de instrucciones, sobre todo en lo que a tamaños de memoria y tamaños de palabra se refiere. Por otro lado, en el Capítulo 10, se estudia en profundidad cómo implementar las unidades secuenciadoras, es decir las unidades que implementan los modos de direccionamiento. Además, al estudiar cómo se implementa cada modo de direccionamiento, el alumno entiende las implicaciones que la elección de los mismos tiene en los tiempos de ejecución de una instrucción. En formatos de instrucciones se abordan algunos aspectos ya tratados en el Capítulo 5. Como se ha explicado, la misión de las instrucciones y sus formatos es recoger y codificar toda la información necesaria para que las instrucciones del repertorio de instrucciones se ejecuten correctamente. En este capítulo se pretende que los estudiantes aprendan a implementar formatos teniendo en cuenta que deben interrelacionar formatos de diferentes tipos de instrucciones con el objetivo de conseguir un diseño óptimo. Este capítulo está muy relacionado con el Capítulo 10 ya que las decisiones de formato pueden afectar a la complejidad de la unidad de control y por lo tanto al rendimiento final del procesador. Por lo que se refiere al Camino de datos y unidad de control, el diseño de procesadores multiciclo permite al alumno comprender las diferentes etapas de ejecución de una instrucción. Se pretende que el alumno se acostumbre a pensar en la descomposición del sistema global en etapas, con los subcaminos necesarios y las señales de control. La ejecución secuencial le permite centrarse en la implementación instrucción a instrucción sin tener que dispersarse estudiando las implicaciones de tener varias instrucciones ejecutándose en paralelo en el procesador. Los problemas se han propuesto de manera que paso a paso se vaya implementando un procesador que hemos llamado TIFÓN. A lo largo del capítulo se van dando diferentes tipos de instrucciones para que se estudie el formato, el camino de datos y el control necesarios para implementarlos. A continuación se van integrando estos caminos en uno único. De esta manera los alumnos pueden observar no sólo cómo se realiza esta integración sino las diferentes opciones de diseño que surgen en este proceso y cómo pueden afectar las decisiones al rendimiento final del procesador. El objetivo del Capítulo 11 son los procesadores segmentados. En este capítulo no se profundiza en implementaciones hardware propiamente dichas, es decir, no se explica cómo implementar las detecciones de riesgos, las paradas o los cortocircuitos, ni se explican técnicas avanzadas como puede ser la planificación dinámica, la predicción de saltos, la especulación o el multilanzamiento. La idea es trabajar sobre los conceptos de segmentación de manera que el lector sea capaz de comprender los riesgos que aparecen para unas determinadas características de segmentación, cómo funcionan las técnicas básicas para evitar pérdidas de rendimiento, y cómo afectan estos riesgos y su tratamiento en el rendimiento final del procesador.

xiv

Introducción

El Capítulo 12 trata de la jerarquía de memoria y de sus principios de localidad espacial y temporal. Desde el inicio de las ciencias de la computación, el programador ha deseado disponer de una memoria ilimitada y extremadamente rápida. El diseño de un espacio de direcciones virtuales y la jerarquía de memoria permiten acercarnos a este hecho. Disponer de un procesador, una jerarquía de memoria y un repertorio de instrucciones tiene poco valor si no existe comunicación o interacción con el mundo exterior, o bien, si al computador inicial no se le pueden acoplar módulos que incorporen nueva funcionalidad al sistema original. Estos módulos son los dispositivos de entrada/salida y se tratan en el Capítulo 13, donde se hace también especial énfasis en los métodos de entrada/salida (programada, por interrupciones o con DMA). El Capítulo 14 complementa al anterior capítulo tratando las interconexiones o buses del computador, ya sea entre sus componentes internos (procesador, memoria) como con los dispositivos de entrada/salida. En este caso no nos hemos centrado tanto en los dispositivos específicos (CD-ROM, ratón, teclado, etc.) como en la arquitectura propia de la entrada/salida y su rendimiento en términos de: ¿qué cantidad de datos se puede mover por el computador por unidad de tiempo?, y ¿cuántas operaciones de entrada/salida se pueden realizar por unidad de tiempo?

1.1 Sistema de numeración binario Un sistema de numeración consta de: Un conjunto ordenado de cifras y un conjunto de operaciones. Llamaremos Base al número de cifras que hay en dicho conjunto. De este modo, el sistema de numeración binario consta de: el conjunto {0, 1}, cuya base es 2. Las operaciones más sencillas son: La suma. La multiplicación. La multiplicación por potencias de la base. Para realizar las dos primeras acudiremos a las tablas de sumar y multiplicar. !

0

1

#

0

1

0

0

1

0

0

0

1

1

0*

1

0

1

* % Genera arrastre

La multiplicación por potencias de la base se realiza del siguiente modo. Sea un número binario n al que vamos a multiplicar por 2m. Si m es positivo moveremos la coma decimal de n m posiciones a la derecha; o también añadiremos m ceros al final. Si m es negativo moveremos la coma decimal de n m posiciones a la izquierda; o también quitaremos m ceros empezando por el final.

2


Ejemplo 1:

Sea n % 11011 y m % 3; entonces:

n . 2m % 11011000 n . 2.m % 11.011

Ejemplo 2:

Sea n % 101.01 y m % 2; entonces:

n . 2m % 10101 n . 2.m % 1.0101

Multiplicar por potencias de la base un número significa multiplicar dicho número por: M%0

M%1

M%2

M%3

M%4

M%5

M%6

M%7

M%8

M%9

M % 10

1

2

4

8

16

32

64

128

256

512

1024

1.2 Cambios de base 1.2.1 Sustitución en serie Se usa cuando S % 10; es decir, cuando queremos pasar a decimal. (N)10 % ; ai . Ri % an.1 . Rn.1 ! ñ ! a0 . R0 ! a.1 . R.1 ! ñ ! a.m . R.m i

Es decir, escribimos el número en notación polinomial y luego calculamos en decimal. Ejemplo 1:

(1A4.C)16 % 1 . 162 ! 10 . 161 ! 4 . 160 ! 12 . 16.1 % 420.75

1.2.2 Multiplicación y división Se usa cuando R % 10; es decir, cuando queremos pasar de decimal a otra. Parte entera: – Dividir (N)10 por S. – El resto será el dígito menos significativo de (N)S. – Repetir el proceso tomando como dividendo el cociente de la división anterior. – El resto será el siguiente dígito menos significativo. – El proceso concluye cuando el cociente es 0. Parte fraccionaria: – Multiplicar por S la parte fraccionaria. – La parte entera del resultado será el dígito más significativo de la parte fraccionaria de (N)S. – Repetir el proceso (puede que no se acabe nunca).

Capítulo 1 Representación de la información

Ejemplo:

3

Pasar (826.17)10 a base 5

1.2.3 Cuando una base es potencia de la otra (R % S x o S % R x) Se usa para pasar de binario a octal y hexadecimal y viceversa: Si R % Sx: Reescribir las cifras de (N)R, en la nueva base S, en grupos de x % Expandir. Ejemplo:

(736.2)8 % (111 011 110 . 010)2

Ejemplo:

(1A4.C)16 % (0001 1010 0100 . 1100)2

Si S % Rx: Juntar las cifras de (N)R en grupos de x pasar dichos grupos a la base S % Comprimir. Ejemplo:

(101 001 011 . 110)2 % (513.6)8

Ejemplo:

(0101 1110 1101 . 0011)2 % (5ED.3)16

Regla Mnemotécnica: «Si dan el n.o en binario hay que comprimir. Si lo dan en octal o hexadecimal hay que expandir».

1.3 Representación de números enteros 1.3.1 Magnitud y Signo (MyS) Bit más significativo % signo Si el n.o es positivo Si el n.o es negativo

r 0 r 1

Resto de los bits % Magnitud. Rango representable: [.(2n.1 . 1), 2n.1 . 1]. El cero tiene doble representación (0 000.0)MyS y (1 000.0)MyS Cálculo del opuesto: Cambiar el signo.

4


Cálculo del valor absoluto (en decimal): Puesto que la magnitud se representa en binario, ya sea el número positivo o negativo, simplemente hay que calcular su equivalente en decimal (se recomienda el método de sustitución en serie).

1.3.2 Complemento a 2 (C2) Mismo convenio para el signo. Resto de los bits % Magnitud. Rango representable: [.(2n.1), 2n.1 . 1] donde el .(2n.1) se representará como (1 000...(n.1)...00)C2. El cero tiene una única representación: (0 000...0)C2. Cálculo del opuesto: Tomar el n.o dado (ya sea positivo o negativo) y calcular su C2. Para ello usaremos el siguiente método: 1.o

Copiar los bits uno a uno, empezando por la derecha, hasta que aparezca el primer 1 (inclusive).

2.o

Negar los bits restantes, es decir cambiar los 0’s por 1’s y los 1’s por 0’s.

Cálculo del valor absoluto (en decimal): – Si el n.o es positivo r la mag. está en binario r Aplicar el método de sust. en serie. – Si el n.o es negativo r la mag. está en C2 r Calcular su opuesto (i.e. su C2) r ñ ñ r Aplicar el método de sustitución en serie.

1.3.3 Complemento a 1 (C1) Mismo convenio para el signo. Resto de los bits % Magnitud. Rango representable: [.(2n.1 . 1), 2n.1 . 1]. El cero tiene dos representaciones: (0 000 ñ 0)C1 y (1 111 ñ 1)C1. Cálculo del opuesto: Tomar el n.o dado (ya sea positivo o negativo) y calcular su C1. Para ello usaremos el siguiente método: Copiar los bits uno a uno, empezando por la derecha, cambiando los 0’s por 1’s y los 1’s por 0’s (es decir, negarlo). Cálculo del valor absoluto (en decimal): – Si el n.o es positivo r la mag. está en binario r Aplicar el método de sust. en serie. – Si el n.o es negativo r la mag. está en C1 r Calcular su opuesto (i.e. su C1) r ñ ñ r Aplicar el método de sustitución en serie. Utilidad del C1: Podemos calcular un n.o en notación C2 sumándole 1 a la notación C1 que tiene un método más rápido (desde el punto de vista del PC).


5

1.3.4 Código BCD Cada dígito del número dado se codifica con su equivalente en binario, usando 4 bits: 0 % 0000

1 % 0001

2 % 0010

3 % 0011

4 % 0100

5 % 0101

6 % 0110

Ejemplo:

7 % 0111

8 % 1000

9 % 1001

(0010 0110 1000)BCD % 268

1.4 Representación de números en coma flotante La representación en coma flotante está basada en la notación científica. La coma decimal no se halla en una posición fija dentro de la secuencia de bits, sino que su posición se indica como una potencia de la base: signo YZ[

exponente YZ[

signo YZ[

! 6.02 . 10.23 VWX mantisa

exponente YZ[

! 1.01110 . 2.1101

VWX base

V∫∫W∫∫X mantisa

VWX base

En todo número en coma flotante se distinguen tres componentes: — — — —

Signo: indica el signo del número (0 % positivo, 1 % negativo). Mantisa: contiene la magnitud del número (en binario puro). Exponente: contiene el valor de la potencia de la base (sesgado). La base queda implícita y es común a todos los números, la más usada es 2.

El valor de la secuencia de bits (s, ep.1, ..., e0, mq.1, ..., m0) es: (.1)s . V(m) . 2V(e) Dado que un mismo número puede tener varias representaciones (0.110 . 25 % 110 . 22 % 0.0110 . 26) los números suelen estar normalizados: – un número está normalizado si tiene la forma 1.xx... . 2xx... (o 0.1xx ... . 2xx...) – dado que los números normalizados en base 2 tienen siempre un 1 a la izquierda, éste suele quedar implícito (pero debe ser tenido en cuenta al calcular el valor de la secuencia). Sea el siguiente formato de coma flotante de 32 bits (base 2, normalizado)

6


El rango de valores representable por cada uno de los campos es: – Exponente (8 bits con sesgo de 128): .128 ... !127. – Mantisa (23 bits normalizados): los valores binarios representables oscilan entre 1.00... y 1.11..., es decir entre 1 y 2-2.23 (2-ulp) (1.11...1 % 10.00...0 . 0.0...1).

Obsérvese que la cantidad de números representables es 232 (igual que en coma fija). Lo que permite la representación en coma flotante es ampliar el rango representable a costa de aumentar el espacio entre números representable (un espacio que no es uniforme).

IEEE 754 2 formatos con signo explícito, representación sesgada del exponente (sesgo igual a (2n.1 . 1 % 127), mantisa normalizada con un 1 implícito (1.M) y base 2. – precisión simple (32 bits): 1 bit de signo, 8 de exponente, 23 de mantisa 1.0 . 2.126 ... (2 . 2.23) . 2127 % 1.2 . 10.38 .. 3.4 . 1038 – precisión doble (64 bits): 1 bit de signo, 11 de exponente, 52 de mantisa 1.0 . 2.1022 ... (2 . 2.52) . 21023 % 2.2 . 10.308 .. 1,8 . 10308 2 formatos ampliados para cálculos intermedios (43 y 79 bits). Codificaciones con significado especial – Infinito (e % 255, m % 0): representan cualquier valor de la región de overflow. – NaN (Not-a-Number) (e % 255, m b 0): se obtienen como resultado de operaciones inválidas. – Número denormalizado (e % 0, m b 0): es un número sin normalizar cuyo bit implícito se supone que es 0. Al ser el exponente 0, permiten representar números en las regiones de underflow. El valor del exponente es el del exponente más pequeño de los números no denormalizados: .126 en precisión simple y .1022 en doble. – Cero (e % 0, m % 0): número no normalizado que representa al cero (en lugar de al 1).


7

Excepciones: – Operación inválida: ä u ä, 0ä#, 0 $ 0, ä$ä, x mod 0, ∂x cuando x a 0, x % ä. – Inexacto: el resultado redondeado no coincide con el real. – Overflow y underflow. – División por cero. El estándar exige que el resultado de las operaciones sea el mismo que se obtendría si se realizasen con precisión absoluta y después se redondease. Hacer la operación con precisión absoluta no tiene sentido pues se podrían necesitar operandos de mucha anchura. Existen 4 modos de redondeo: – Redondeo al más cercano (al par en caso de empate). – Redondeo a más infinito (por exceso). – Redondeo a menos infinito (por defecto). – Redondeo a cero (truncamiento). Al realizar una operación, ¿cuántos bits adicionales se necesitan para tener la precisión requerida? – Un bit r para el redondeo. – Un bit s (sticky) para determinar, cuando r%1, si el número está por encima de 0,5. Tabla de operaciones de redondeo Tipo de redondeo

Signo del resultado n 0

Signo del resultado a 0 !1 si (r or s)

.ä !1 si (r or s)

!ä 0 Más próximo

!1 si (r and p0) or (r and s)

!1 si (r and p0) or (r and s)

1.5 Problemas resueltos PROBLEMA 1 Sea la siguiente secuencia de ceros y unos: A % 00101100 y B % 10010111. Indicar qué valor representan en decimal si son números: a) Binarios

b) En notación C1

d) En código BCD

e) En código Exceso-3

c)

En notación C2

8


Solución: a) Para pasar de binario a decimal hay que sumar los pesos de los unos. En A tenemos unos en las posiciones 2, 3 y 5 (recordar que el bit menos significativo ocupa la posición 0). En B tenemos unos en las posiciones 0, 1, 2, 4 y 6. En definitiva: (A)10 % 22 ! 23 ! 25 % 44; (B)10 % 20 ! 21 ! 22 ! 24 ! 27 % 151. b) Para pasar de notación C1 a decimal los números cuyo signo es positivo, o sea el bit más significativo es 0, se procede exactamente igual que si estuvieran en binario puro. (A)10 % ! (22 ! 23 ! 25) % 44 Si el número es negativo, el bit más significativo es 1, primero hay que pasar a binario puro su magnitud. Esto se logra complementando todos los bits. Después ya se procede igual que en los casos anteriores. (B)10 % . (01101000)2 % . (23 ! 25 ! 26) % .104 c)

Para pasar de notación C2 a decimal los números cuyo signo es positivo, o sea el bit más significativo es 0, se procede exactamente igual que si estuvieran en binario puro o en C1 (A)10 % ! (22 ! 23 ! 25) % 44 Si el número es negativo, el bit más significativo es 1, primero hay que pasar a binario puro su magnitud. Esto se logra copiando los bits del número, comenzando por el menos significativo, hasta que aparece el primer uno inclusive. A partir de él se complementan todos los demás. Después ya se procede igual que en los casos anteriores. (B)10 % . (01101001)2 % . (20 ! 23 ! 25 ! 26) % .105

d) A no puede ser BCD porque el 1101 no pertenece al código; (B)10 % 97. e)

A no puede ser Ex3 porque el 0010 no pertenece al código; (B)10 % 64.

PROBLEMA 2 Marca con un círculo la única afirmación cierta: a) (1000)2 % ... b) (37)8 % ... c) (1000)BCD % ... d) (0101)C2 ! (1010)C2 % ... a)

(.8)10

b)

(8)10

c)

Overflow si ancho % 4

d) Ninguna

a)

(011111)2

b)

(0307)16

c)

(00110111)BCD

d) Ninguna

a)

(1000)2

b)

(.8)10

c)

El 1000 no es BCD

d) Ninguna

a)

(15)10

b)

(.1)10

c)

Overflow si ancho % 4

d) Ninguna


9

Solución: a) (1000)2 % b) (8)10 porque al ser un número en binario puro calculamos su equivalente en decimal sumando los pesos de los unos que aparecen. El único uno está en la posición 3 y por tanto su peso es 23 % 8. b) (37)8 % a) (011111)2 porque para pasar de base 8(% 23) a base 2 debemos rescribir cada cifra del número en base 8 con 3 bits; de este modo 3 % 011 y 7 % 111. c) (1000)BCD % a)

(1000)2 porque el dato dado es la codificación del 8 en base 10.

d) (0101)C2 ! (1010)C2 % b) (.1)10 porque el primer operando es el (5)10 y el segundo es el (.6)10. PROBLEMA 3 Completar la tabla a) (128)10 % (...................................)16 b) (12)10 % (...................................)BCD c)

(10000)C2 ! (01010)C2 % (...................................)C2

d) (1101)MyS % (...................................)C1 Solución: a) (128)10%27%(10000000)2%(80)16. b) Rescribiendo 1 % 0001 y 2 % 0010 queda (12)10%(00010010)BCD. c)

La suma de dos números en notación C2 se realiza bit a bit y el último acarreo se pierde, por tanto: (10000)C2 ! (01010)C2 % (11010)C2

d) El (1101)MyS % .(5)10 porque el bit más significativo representa el signo y el resto su valor absoluto en binario puro. Para representar el .(5)10 en la notación C1 con 4 bits simplemente hay que escribir el !(5)10 en binario puro con 4 bits y despues complementar todos los bits. Así tendríamos primero 0101 y tras complementar todos los bits queda (1010)C1. PROBLEMA 4 Responde Verdadero o Falso con una V o una F dentro de la casilla de la izquierda de cada frase. a) ⵧ (.1)10 % (11111111)C2 b) ⵧ (1000)C2 ! (0001)C2 desborda con 4 bits c) ⵧ (10011001)BCD % (99)16 d) ⵧ (1100)C2 . (0011)C2 % (1001)C2

10


Solución: a) V. (11111111)C2 % .(00000001)2 % .(1)10 b) F. (1000)C2 ! (0001)C2 % (1001)C2 % .(0111)2 % .(7)10 que está dentro del rango con 4 bits. c)

F. (10011001)BCD % (99)10 Ç (99)16

d) V. (1100)C2 . (0011)C2 % .(0100)2 . (0011)2 % .(4)10 . (3)10 % .(7)10 % (1001)C2 PROBLEMA 5 Completar la tabla a) (11001)C2 ! (11011)C2 % (.............)C2 usando 5 bits. ¿Se produce algún error? b) (F)16 % (.............)8 c)

(16)10%(.............)BCD

Solución: a) Usando 5 bits (11001)C2 ! (11011)C2 % (10100)C2. No se produce ningún error porque la operación, en decimal, es (.7) ! (.5) % (.12); precisamente el resultado obtenido. b) (F)16 % (001111)2 % (17)8 c)

(16)10 % (00010110)BCD

PROBLEMA 6 Responde Verdadero o Falso con una V o una F dentro de la casilla de la izquierda de cada frase. a) ⵧ (AB)16 no se puede representar en C2 b) ⵧ (468)8 % (0100 0110 1000)2 c) ⵧ (1111)BCD % .(1)10 d) ⵧ (1010)C2 ! (0101)C2 desborda con ancho de 4 bits Solución: a) F. (AB)16 se corresponde con un número entero positivo, que con los suficientes bits, siempre se podrá representar en el convenio C2, en (010101011)C2. b) F. Es imposible que el 468 sea un número en base 8, la representación utiliza los dígitos de 0 a 7. c)

F. 1111 no pertenece al código BCD.

d) F. (1010)C2 ! (0101)C2 % (1111)C2. No se produce desbordamiento.


11

PROBLEMA 7 Escribir el siguiente sistema de ecuaciones, representado en decimal, en base 5: 6x . 5y % 11 3x . 14y % 9 Solución: Debemos rescribir cada una de las cifras del sistema de ecuaciones en base 5. (6)10 % (11)5, (5)10 % (10)5, (11)10 % (21)5, (3)10 % (3)5, (14)10 % (24)5, (9)10 % (14)5 luego el sistema es 11x . 10y % 21 3x . 24y % 14 PROBLEMA 8 Indicar, razonando la respuesta, en qué casos hay desbordamiento si queremos: a) Representar (16)2 con 4 bits. b) Representar (.4)C1 con 3 bits. c)

Representar (.8)C2 con 4 bits.

d) Representar (5)MyS con 3 bits. Solución: Habrá desbordamiento cuando el número que queremos representar no pertenece al rango según el número de bits disponibles. a) Con 4 bits el rango en binario es [0, 15] por tanto hay desbordamiento. b) Con 3 bits el rango en C1 es [.3, !3] por tanto hay desbordamiento. c)

Con 4 bits el rango en C2 es [.8, !7] por tanto no hay desbordamiento.

d) Con 3 bits el rango en MyS es [.3, !3] por tanto hay desbordamiento. PROBLEMA 9 Sea la secuencia 0110 1000 0011 1010. a) Suponiendo que se trata de un n.o binario, calcular su equivalente en octal y en hexadecimal e indicar su equivalente en decimal. b) Suponiendo que se trata de un n.o en BCD calcular su equivalente decimal.

12


Solución: a) (64072)8 % (683A)16 % (21 ! 23 ! 24 ! 25 ! 23 ! 211 ! 213 ! 214)10 b) Es imposible que sea BCD puesto que el 1010 no pertenece a dicho código. PROBLEMA 10 Responde a las siguientes preguntas. a) ¿Cuál es el equivalente, en decimal, del (1000)C2? b) ¿Cuál es el equivalente, en notación C2, del (1011)BCD? c)

¿Cuál es el equivalente, en binario, del (257)8?

d) ¿Cuál es el equivalente, en notación C1, del (1100)C2? Solución: a) Con 4 bits el rango representable en C2 es [.8, !7] siendo .8 precisamente un 1 seguido de tres ceros. Luego la respuesta es .(8)10. b) El 1011 no pertenece al BCD por lo tanto no puede tener equivalente en C2. c)

Como el número dado está en base 8 % 23 debemos rescribir cada cifra con 3 bits. Así 2 % 010, 5 % 101, 7 % 111 y el resultado final es (010 101 111)2.

d) El (1100)C2 es el .(0100)2. Complementando los bits obtenemos la representación en notación C1: (1011)C1. PROBLEMA 11 Responde a las siguientes preguntas. a) ¿Cuánto hay que sumar a (111)C2 para obtener (100)C2? b) ¿Cuánto hay que restar a (111)C1 para obtener (100)C1? c)

¿Cuánto hay que sumar a (111)MyS para obtener (100)MyS?

Solución: a) (111)C2 ! (X)C2 % (100)C2, luego (X)C2 % (100)C2 . (111)C2 (100)C2 .(111)C2 %(100)C2 !(001)C2 % (101)C2; Recordar que el último carry se pierde. b) (111)C1 . (X)C1 % (100)C1, luego (X)C1 % (100)C1 . (111)C1 (111)C1 . (100)C1 % (111)C1 ! (011)C1 % (011)C1; Recordar que el último carry se vuelve a sumar. c)

.(3)10 ! X % 0, luego X % (3)10 % (011)MyS


13

PROBLEMA 12 Cambiar a decimal los siguientes números. En caso de que no se pueda indicar qué tipo de error es. a) (10101)C2 % b) (1111)mys % c)

(10000)C1 %

d) (0111)C2 % e)

(0011 1100)ex3 %

f)

(1010)BCD %

Solución: a) Es negativo y está en notación C2 de modo que tenemos que obtener su magnitud copiando hasta el primer uno inclusive y complementando el resto de bits. Queda .(01011)2 % .11. b) Es negativo y está en Magnitud y Signo por tanto su bit más significativo es el signo y el resto la magnitud en binario puro. Queda entonces .(0111)2 % .7. c) Es negativo y está en notación C1 de modo que tenemos que obtener su magnitud complementando todos los bits. Queda .(01111)2 % .15. d) Es positivo y por tanto su equivalente decimal se calcula como si se tratase de un número binario puro de 4 bits. En este caso se trata del 7. e) En el código exceso 3 cada cifra del sistema decimal se representa con 4 bits de modo que el 0 se corresponde con el 0011, el 1 con el 0100, el 2 con el 0101... es decir cada cifra se codifica con su equivalente binario de ancho 4 al que se le ha sumado 3. En este caso 0011 % 0 y 1100 % 9; por tanto el resultado es 9. f) El código 1010 no pertenece al BCD. PROBLEMA 13 Contesta las siguientes preguntas a) (1110 1000)C1 % (¿?)C2 b) (0101 1011)MyS % (¿?)C2 c)

(F5)16 % (¿?)8

d) (1111 1000)C2 % (¿?)10 Solución: a) Puesto que es un número negativo en notación C1, para calcular su representación en C2 basta con sumarle 1. El motivo es que la operación C1(X) % (2n . X) . 1 % C2(X) . 1, siendo n el ancho utilizado. Despejando queda C2(X) % C1(X) ! 1. En definitiva el resultado es (1110 1001)C2 b) Como se trata de un número positivo tendrá la misma representación en Magnitud y Signo, en notación C1 y en notación C2, o sea (0101 1011)C2.

14


c) El modo más fácil es cambiar primero a base 2 y luego a base 8. Puesto que 16 % 24 debemos rescribir cada cifra del número dado con 4 bits. Así tendríamos (1111 0101)2. Para cambiar ahora a base 8 % 23 agrupamos de 3 en 3, comenzanzo por el bit menos significativo, quedando (011 110 101)2 % (365)8. d) El procedimiento es el ya comentado en ejercicios anteriores para números negativos en notación C2. Así obtendríamos primero .(0000 1000)2 % .(8)10. PROBLEMA 14 Realizar las siguientes operaciones indicando si hay error de desbordamiento: a) (1011)C2 . (0111)C2, con 4 bits. b) (1000)BCD ! (0101)BCD, en BCD, usando tantos bits como necesites. c)

Completar (001010111000101)2 % (¿?)8.

Solución: a) La notación C2 se introduce precisamente para evitar hacer restas. En su lugar se realizará la suma del primer operando más el opuesto del segundo. El segundo operando es !(7)10 por tanto su opuesto es .(7)10 que en notación C2 es (1001)C2. Por último recordar que cuando se suman dos números en notación C2 el último acarreo se pierde, sin que ello signifique necesariamente que se ha producido un error de desbordamiento. El resultado es: (1011)C2 ! (1001)C2 % (0100)C2 En este caso, sin embargo, sí se produce desbordamiento porque la operación en decimal es .5 . 7 % .12 que no se puede representar en C2 con sólo 4 bits. b) Pasando a decimal cada uno de los operandos tenemos 8 ! 5 % 13 % (0001 0011)BCD. c)

Agrupando de 3 en 3 como se explicó en el apunte teórico y en ejercicios anteriores queda (12705)8.

PROBLEMA 15 Completar la tabla: a) (38)10 % (...............)8 b) (10000111)BCD%(...............)10 c)

(10000)C2 % (...............)C2 . (01010)C2

d) (0101)C1 % (...............)MyS Solución: a)

% 32 ! 6 % (100000)2 ! (00110)2 % (100110)2 % (46)8.

b) Agrupando de 4 en 4, comenzando por el menos significativo tenemos 1000 % 8 y 0111 % 7. En definitiva (87)10.


c)

15

(10000)C2 % (X)C2 . (01010)C2. Despejando (10000)C2 ! (01010)C2 % (X)C2. Finalmente la suma en C2 se realiza directamente (10000)C2 ! (01010)C2 % (11010)C2.

d) Es un número positivo y por tanto tiene la misma representación % (0101)MyS. PROBLEMA 16 Completar la tabla: a) (128)10 % (...................)16 b) (12)10 % (...................)BCD c) (10000)C2 ! (01010)C2 % (...................)C2 d) (1101)MyS % (...................)C1 Solución: a) % 27 % (1000 0000)2 % (80)16 b) (0001 0010)BCD c)

(10000)C2 ! (01010)C2 % (11010)C2

d) % .(0101)2 % (1010)C1 PROBLEMA 17 Calcular: a) (11001)C2 ! (11011)C2 % (................)C2 usando 5 bits. b) ¿Se produce algún error en el cálculo anterior? c)

(F)16 % (................)8

d) (16)10 % (................)BCD Solución: a) (11001)C2 ! (11011)C2 % (10100)C2 b) La operación en decimal es .7 ! .5 % .12, que con 5 bits en C2 se representa (10100). Por tanto no hay ningún error. c)

% (1111)2 % (001 111)2(17)8

d) (0001 0110)BCD PROBLEMA 18 Encuentre el número decimal cuya representación en formato IEEE 754 en coma flotante de 32 bits, compactada en hexadecimal es C19E0000.

16


Solución: Paso 1.o Obtención de la información almacenada en el registro a partir de la expresión compactada en hexadecimal. C 1

1

1 0

0

0

0

9 0

1

1

0

E 0

1

1

1

0 1

0

0

0

0 0

0

0

0

0 0

0

0

0

0 0

0

0

0

0

0

Paso 2.o Obtención de la información almacenada en el registro a partir de la expresión compactada en hexadecimal. C 1

1

SGN

1 0

0

0

0

9 0

1

1

0

E 0

1

1

1

0 1

0

0

EXPONENTE

Paso 3.o

0

0 0

0

0

0

0 0

0

0

0

0 0

0

0

0

0

0

MANTISA

Cálculo de los diferentes componentes de la representación en punto flotante:

– Bit de signo % 1

ú El número es negativo

– Mantisa % %1.001111 – Exponente auténtico % Exponente representado . Exceso . Paso 4.o

%10000011 %1111111 00000100 % 4

Cambio de representación del número desde punto flotante a punto fijo Número % .(%1.001111) . (24) % .1.234375 . 16 % .19.75

PROBLEMA 19 Calcule el error, en valor absoluto, que se comete al representar el número decimal 291.072 con el número 4391 en formato IEEE754 (de 16 bits). Solución: Debido a la limitación de la longitud del registro donde se almacena el número IEEE754 (en este caso es de 16 bits, pero siempre existirá algún límite), puede suceder que al convertir de decimal a IEEE754 haya que truncar la mantisa del número decimal. 1

PARTE FRACCIONARIA QUE CABE EN EL REGISTRO PARTE FRACCIONARIA TRUNCADA

Por este motivo, existe la posibilidad de que diferentes números decimales tengan la misma representación IEEE754. D1

1

IGUAL

DIFERENTE 1

D2

1

IGUAL

DIFERENTE 2


17

En este caso, el número en IEEE754 se corresponde exáctamente sólo con aquel decimal cuya parte truncada es nula. DEXACTO

1

IGUAL

000...

Cuando se quiere conocer el error (en valor absoluto) cometido al representar un decimal di con el número F en IEEE754, por definición se calcula el valor absoluto de su resta: Error absoluto % |d i . F| (en esencia, toda comparación consiste en una substracción). Por suspuesto, las comparaciones sólo se pueden hacer entre entidades homogéneas, por ello ambos números deben estar en el mismo formato. Como las operaciones artiméticas se realizan de forma más directa en decimal que en IEEE754, convertimos el IEEE754 a decimal; y luego calculamos el valor absoluto de la resta. Obsérvese que al hacer esto estamos comparando el número di con el número dexacto. Conversión del IEEE754 a decimal Paso 1.o Obtención de la información almacenada en el registro a partir de la expresión compactada en hexadecimal. Paso 2.o o

Paso 3.

Identificación de los diferentes campos presentes en el registro. Cálculo de los diferentes componentes de la representación en punto flotante.

– Bit de signo % 0 ú El número es positivo. – Mantisa % %1.0010001 – Exponente auténtico % Exponente representado . Exceso. . Paso 4.o

%10000111 %1111111 00001000 % 8

Cambio de representación del número desde punto flotante a punto fijo. Número % (%1.0010001) . (28) % %100100010 % &200

Comparación Error absoluto % |d i . dexacto| % |291.072-290| % 1.072 PROBLEMA 20 Se tiene un sumador/restador en coma flotante que opera con números de 16 bits representados con el siguiente formato: Exponente: 8 bits en exceso 28-1. Mantisa: 8 bits en complemento a 2, normalizada y fraccionaria. a) Realizar la suma de los números A y B, tal como lo haría dicho sumador. Suponiendo que A: 1000 0011 | 0110 0011 y B: 1000 0110 | 1001 1100 (exponente | mantisa) b) ¿Existe alguna diferencia entre el resultado obtenido por este sumador y el resultado real? ¿Por qué?

18


Solución: a) 1.

Primero separamos mantisa y exponentes: A 1000 0011 0110 0011

Exponente Mantisa 2.

B 1000 0110 1001 1100

Comparamos los exponentes Exponente A % 3 Exponente B % 6

3.

Alineamos las mantisas y realizamos la suma. Para alinear desplazamos hacia la derecha la mantisa afectada del menor exponente. Se desplaza 3 veces (exponente B . exponente A) y realizamos la suma: 1001 1100 0000 1100 011 ! (los bits tachados se pierden al desplazar) 1010 1000

4.

Normalizar el resultado. El valor del resultado se encuentra normalizado ya que la mantisa está expresada en C2. Por tanto el resultado es Exponente Mantisa

b) 1.

Valor de A Exponente Mantisa Valor

2.

1000 0011 1001 1100 .(2.2 ! 2.3 ! 2.8) . 26 % .25

Calculamos el valor del resultado anterior Exponente Mantisa Valor

4.

1000 0011 0110 0011 (2.2 ! 2.3 ! 2.7 ! 2.8) . 23 % 3,09375

Valor de B Exponente Mantisa Valor

3.

Resultado 1000 0110 1010 1000

1000 0110 1010 1000 .(2.2 ! 2.4 ! 2.5) . 26 % .22

Realizando la suma de ambos valores A ! B % .25 ! 3,09375 % .21,09625. El resultado tiene un error con respecto al obtenido debido a que al desplazar a la derecha la mantisa se pierden bits con información significativa.


19

PROBLEMA 21 Se tiene un sumador de coma flotante que opera con números de 16 bits representados en el formato siguiente: Exponente Mantisa Exponente: 8 bits, representado en exceso 2n . 1. Mantisa: 8 bits, representada en complemento a 2, fraccionaria, normalizada y no emplea bit implícito. El sumador opera con un bit de guarda y un bit retenedor y se emplea como técnica de redondeo la de redondeo al más próximo. Sean los números A y B siguientes A 1000 1010 0100 0011 Se pide:

B 1000 0101 0111 0000

a) Realizar la suma de A y B tal y como lo haría el sumador. b) Calcular el valor en decimal del resultado. c)

Calcular el valor real de la suma, también en decimal si se hubiese realizado a mano.

d) Si existe diferencia entre los apartados b) y c) explicar a qué es debido. e)

¿Cambiaría el resultado si en lugar de redondeo al más próximo empleásemos la técnica de forzar el bit menos significativo a uno?

Solución: a) 1.

Separar mantisas y exponentes. Exponente Mantisa

2.

A 1000 1010 0100 0011

B 1000 0101 0111 0000

Comparar los exponentes Exponente A % 10 Exponente B % 5 Por tanto el exponente para el resultado, salvo que haya que normalizar, será el exponente de A.

3.

Alineamos las mantisas y realizamos la suma. Para alinear desplazamos hacia la derecha la mantisa afectada del menor exponente. Se debe desplazar 5 veces (exponente A . exponente B) y realizar la suma. 0100 0011 00 0000 1100 10 ! (los bits en cursiva son el bit de guarda y el retenedor 0100 0110 10 respectivamente)

4.

Normalizar el resultado. El valor del resultado se encuentra normalizado ya que la mantisa está expresada en C2.

20


5.

Redondear el resultado. Al ser redondeo al más próximo y contar con los bits de guarda y retenedor con el valor 10, se deberá comprobar si el bit menos significativo del resultado es cero o uno, para sumar cero o uno respectivamente al mismo. Al ser 0 (0100 0110) se le sumaría cero y por lo tanto el resultado es: Exponente Mantisa

Resultado 1000 1010 0100 0110

b) Calculamos el valor del resultado anterior Exponente Mantisa Valor c)

1000 0110 1010 1000 (2.2 ! 2.6 ! 2.7) . 210 % 280,0

Calculamos el valor de A Exponente Mantisa Valor

1000 1010 0100 0011 (2.2 ! 2.7 ! 2.8) . 210 % 268,0

Calculamos el valor de B Exponente Mantisa Valor

1000 0101 0111 0000 (2.2 ! 2.3 ! 2.4) . 25 % 14,0

Por lo tanto tendríamos 268,0 ! 14,0 % 282,0 d) Es debido a los desplazamientos para alinear las mantisas y a la pérdida de precisión que sufren los números fraccionarios al pasarlos a coma flotante. e)

Al forzar el bit menos significativo a uno, el resultado sería el siguiente: Exponente Mantisa Valor

1000 1010 0100 0111 (2.2 ! 2.6 ! 2.7 ! 2.8) . 210 % 284,0

PROBLEMA 22 Dados los siguientes números representados en decimal: a) 35 b) 12,5 Representar dichos números en coma flotante según el estándar IEEE 754 de precisión simple. Solución: a) 35 % 17,5 * 21 % 8,75 * 22 % 4,375 * 23 % 2,1875 * 24 % 1,09375 * 25 Mantisa: 0,09375 ú

00011000000000000000000

Exponente: 5 ! 127 % 132

ú

10000100


21

b) 12,5 % 6,25 * 21 % 3,125 * 22 % 1,5625 * 23 Mantisa: 0,5625 ú

10010000000000000000000

Exponente: 3 ! 127 % 130

ú

10000010

PROBLEMA 23 Considérese un computador que representa los números en coma flotante según un supuesto estándar IEEE754 de precisión reducida con 16 bits (1 bit para el signo, 5 bits para el exponente sesgado y 10 bits para la mantisa). Se pide: a) ¿Cuál es el valor del sesgo para el exponente? b) ¿Cuál es el valor del menor número representable en valor absoluto? c)

¿Cuál es el valor del menor número representable?

d) Representar los números decimales 8,5 y 3,75 en el estándar definido. e) Sumar los números anteriores siguiendo el algoritmo de suma del estándar IEEE754 aplicado al formato de 16 bits. Solución: a) El sesgo será 2k.1 . 1, siendo k el número de bits utilizados en el campo exponente. Como k % 5, el sesgo será 25.1 . 1 % 15. b) Como el exponente tiene 5 bits, tendrá valores comprendidos entre 0 y 31, pero el 0 y el 31 se utilizan como excepciones, por lo que el menor valor del exponente será 1. La menor mantisa será 0000000000. Por tanto el menor número representable en valor absoluto será: 2E.15 # 1.M % 21.15 # 1.0000000000 % 2.14 c)

El menor número representable será el número negativo con mayor valor absoluto. Signo negativo % 1 Mayor exponente % 30 (ya que el 31 se usa como excepción). Mayor mantisa % 1111111111 Por tanto el menor número representable será: (.1)S 2E.15 # 1.M % .230.15 # 1.1111111111 % .215 # (2 . 2.10) ya que: 2 % 10.0000000000 2.10 % 0.0000000001 2 . 2.10 % 1.1111111111

22


d)

8,5 % 1000,1(2 % 1,0001 # 23

ú

0

10010 (3 ! 15) 0001000000

1

ú

0

10000 (1 ! 15) 1110000000

3,75 % 11,11(2 % 1,111 # 2 e)

N1 % 8,5 % 0

10010

N2 % 3,75 % 0

10000

0001000000 1110000000

Se restan los exponentes: E1 . E2 % 10010 . 10000 % 00010 % 2(10. Se desplaza la mantisa del número de menor exponente dos lugares a la izquierda, incluyendo el bit no visible. 1.M2 % 1.1110000000 ú 0.0111100000 Se suman las mantisas 1.M1 y 1.M2 desplazada: 1.0001000000 ! 0.0111100000 % 1.1000100000 Como es de la forma 1.M, no es necesario normalizar el resultado. El resultado final es: 0

10010

1000100000%!218.15#(20!2.1!2.5)%8#(1!0,5!0.03125)%12,25

1.6 Problemas propuestos PROBLEMA 1 ¿Cuál de las afirmaciones es cierta? (Sólo hay una en cada caso) (1001)C2 %

ⵧ (9)10

ⵧ (.9)10

ⵧ (7)10

ⵧ (.7)10

(0101)2 %

ⵧ (0101)BCD

ⵧ (1010)C1

ⵧ (1011)C2

ⵧ Ninguna

(10100101)2 %

ⵧ (105)BCD

ⵧ (505)8

ⵧ (A5)16

ⵧ Ninguna

(101)C2 . (111)C2 %

ⵧ (110)C2

ⵧ (100)C2

ⵧ (000)C2

ⵧ Ninguna

PROBLEMA 2 Marca con un círculo la única afirmación es cierta: (100)C2 % ... a) (.4)10

b) (4)10

c)

Overflow

d) Ninguna de las anteriores

c)

(00100101)BCD


c)

(1010)C1


c)

Overflow


(25)16 % ... a) (00100101)2 b) (0205)8 (1111)BCD % ... a) (15)10

b) (0101)2

(0111)C2 . (1110)C2 % ... a) (1111)C2

b) (1001)C2


23

PROBLEMA 3 Marca la casilla que contenga la única respuesta correcta: a) (0101)BCD ! (0111)BCD %

ⵧ ..(1100)BCD,

ⵧ ..(0011)BCD,

ⵧ ..(0010)BCD,

ⵧ ..Ninguna de las anteriores

b) (01101)C2 ! (00110)C2, utilizando un máximo de 5 bits, es igual a:

ⵧ ..(01101)C2,

ⵧ ..(10000)C2,

ⵧ ..Desbordamiento,


c)

(A42)16 %

ⵧ ..(1042)10,

ⵧ ..(5102)8,

ⵧ ..(1010 0100 0010)BCD,


d) El rango representable con 5 bits en la notación Complemento a 2 es:

ⵧ ..[.31, 31],

ⵧ ..[.32, 32],

ⵧ ..[.31, 32],


PROBLEMA 4 Sean A % (10101)C2 y B % (00100)C2; entonces (A . B)C2, con ancho n % 5,...

ⵧ ..es igual a (11000)C2

ⵧ ..es igual a (.15)10

ⵧ ..desborda


PROBLEMA 5 Sea A % (0010 1110)2; entonces.

ⵧ ..(A)8 % (216)8

ⵧ ..(A)16 % (2E)16

ⵧ ..(A)BCD no se puede representar


PROBLEMA 6 Con ancho n % 3, el rango representable en notación C2 es...

ⵧ ..[.4, !4]

ⵧ ..[.3, !3]

ⵧ ..[.4, !3]


PROBLEMA 7 Utilizando ancho n % 5. ¿Qué número hay que sumar a (10000)C1 para obtener (10101)C1?

ⵧ ..(00101)C1

ⵧ ..(11010)C1

ⵧ ..El número necesario no cabe en 5 bits


24


PROBLEMA 8 En qué base está la siguiente ec: 3x . y ! z % 11 si tiene como soluciones {x % 5, y % 4, z % 2} ⵧ ..14 ⵧ ..15

ⵧ ..16


PROBLEMA 9 Obtenga la representación del número 1540 en formato normalizado IEEE 754 para coma flotante de 32 bits. PROBLEMA 10 Considerar un sumador/restador que opera con datos representados en coma flotante, con mantisa normalizada y fraccionaria expresada en Ca1 y exponente representado en exceso 24-1, además dicha unidad opera con dos dígitos de guarda y un bit retenedor. Emplea el redondeo al más próximo. Calcular la suma de A ! B, siendo A: 1101 | 10110

y

B: 1101 | 01011 (exponente | mantisa)

PROBLEMA 11 Sabiendo que A: 110011 y B: 010001 están ambos representados en binario puro calcular el producto de A # B utilizando el algoritmo de suma-desplazamiento. Realizar paso a paso dicho producto, sabiendo que el resultado se almacenará en un registro P de 12 bits, formado por dos registros concatenados P1 y P0 de 6 bits. PROBLEMA 12 Calcular el producto de A # B, sabiendo que A: 111110 y B: 1111111 están representados en C2. PROBLEMA 13 Sea un computador que trabaja con el siguiente sistema de representación de la información para coma flotante: Exponente expresado en exceso 2n . 1 con 8 bits. Mantisa expresada en complemento a 1, normalizada y sin bit implícito con 8 bits.

2.1 Especificación mediante Funciones de Conmutación (F.C.) Una tabla de verdad expresa la salida del sistema para cada una de las posibles combinaciones de los bits de entrada. Para construirla escribimos todos los posibles valores que pueden tomar las entradas y su correspondiente salida. Si el sistema tiene n bits para codificar la entrada habrá 2n posibilidades (filas). Las columnas de la derecha son las FC de cada una de las m salidas del sistema. Las FC se obtendrán a partir de la descripción de alto nivel que hagamos del sistema y de la codificación que elijamos. Sólo en el caso de que la entrada no esté permitida podremos dejar la salida sin especificar o don’t care, y en este libro se representará por X.

2.2 Especificación mediante Expresiones de Conmutación (E.C.) Otra forma de describir el comportamiento de un sistema es mediante el Álgebra de Boole y ecuaciones que relacionen las salidas con las entradas. A grosso modo podemos decir que estas ecuaciones se construyen con los operadores básicos del Álgebra de Boole NOT, AND y OR (., ! , . )

26


Ejemplo:

x2 x1 ! (x3 ! x1)x2

A partir de una E.C., y mediante el álgebra de Boole, podemos encontrar otras E.C. equivalentes, es decir, que modelan el mismo sistema combinacional. E.C. r F.C. Para encontrar la F.C. correspondiente a una E.C. dada simplemente tenemos que calcular qué resultado da la E.C. cuando la evaluamos sobre todas y cada una de las posibles entradas que puedan ocurrir. Ejemplo:

Sea un sistema modelado por la siguiente E.C. z % x1 ! x0; del que queremos calcular sus F.C.s. Es decir, queremos calcular su Tabla de Verdad. Lo primero será escribir la T.V. que siempre es igual a todo sistema de dos entradas y 1 salida:

F.C. r E.C. Definición de minitérmino: Es un término producto donde todas las variables aparecen una y sólo una vez, ya sea complementadas o sin complementar. Los minitérminos se representan por mi, donde i es el equivalente en decimal del número binario que se obtiene al sustituir las variables negadas por 0 y las no negadas por 1. Ejemplo:

x3 x2 x1 x0 % 1010 % 10

á

m10

De esta manera puedo ver la tabla de verdad como una tabla que me indica qué minitérminos dan salida 0, qué minitérminos dan salida 1 y cuáles dan salida indeterminada.

A partir de la F.C. podemos calcular la E.C. como la suma de todos los minitérminos que dan salida % 1; es decir, la salida Z % 1 si se cumple alguna de las entradas correspondientes. A dicha suma la llamamos Suma de Productos Canónica.

Capítulo 2 Sistemas combinacionales

27

En el ejemplo tendríamos: Z % ; m(0, 1, 4) % x2 x1 x0 ! x2 x1 x0 ! x2 x1 x0

2.3 Simplificación mediante mapas de Karnaugh Los mapas de K. son otra forma de escribir las F.C.; en vez de hacerlo en columnas se hace en forma matricial. Cada casilla de la matriz representa un minitérmino. Además se cumple que los minitérminos correspondientes a dos casillas juntas o adyacentes se diferencian en un único literal (o bit). Los mapas sirven para simplificar Sumas de Productos canónicas (i.e. Sumas de minitérminos), obteniendo Sumas de Productos tal que haya el mínimo número de términos producto. El procedimiento es el siguiente: 1.

Introducir en las casillas los valores de la F.C.

2.

Cubrir todas las casillas con el menor n.o de rectángulos, cada uno de ellos lo más grande posible.

3.

Cada rectángulo es % producto de los literales idénticos de los minitérminos que lo forman.

4.

Las casillas que den salida indeterminada se usarán como comodín, de modo que podré formar rectángulos con ellas sólo si me conviene.

5.

La E.C. % Suma de los cuadrados.

6.

Para averiguar qué literales son comunes a los minitérminos que forman un rectángulo veremos en qué franjas está sumergido.

En las figuras se muestran los mapas de 3 y 4 variables tal y como se utilizarán a lo largo de este libro. La numeración se corresponde con el minitérmino asociado a la casilla.

2.4 Implementación de sumas de productos Con puertas NOT, AND y OR

28


1.

Una puerta OR con n entradas (tantas como términos producto haya).

2.

Tantas puertas AND como términos producto haya (en general serán n).

3.

La salida de cada puerta AND se conecta con una de las entradas de la puerta OR.

4.

Para implementar los literales (negados y sin negar) uso puertas negadoras.

Ejemplo:

f (x, y, z) % xy ! xz ! y, y su implementación es la Figura 1.

Con puertas NAND 1.

Implementar la ecuación con puertas AND y OR.

2.

Cambiar todas las puertas AND por puertas NAND.

3.

Cambiar la puerta OR por una puerta OR con las entradas negadas.

4.

Si alguna de las entradas de la puerta OR venía de un literal en vez de a una AND r negar dicho literal (podemos usar una NOT o, mejor aún, construir una a partir de puertas NAND).

5.

Sustituir la OR con entradas negadas por su equivalente, i.e.: la NAND.

Ejemplo:

f (x, y, z) % xy ! xz ! y, y su implementación es la Figura 2.

2.5 Análisis de sistemas combinacionales El análisis es el proceso mediante el cual se obtiene la especificación de un sistema a partir de una implementación dada. Método general 1.

Colocar puntos a la salida de cada puerta o módulo del sistema.

2.

Resolver la red; i.e.: ir despejando cada punto, que la mayor parte de las veces depende del valor de otros puntos anteriores, hasta que obtengamos la ecuación de la salida.

Red NAND / NOR 1.

Identificar los niveles a los que pertenecen las puertas.

2.

Cambiar las puertas de los niveles impares por su puerta equivalente (de entradas negadas) de forma que las negaciones a la salida de los niveles pares se anulen con las entradas negadas de los niveles impares.

3.

De este modo nos queda una red de puertas AND-OR mucho más sencilla de analizar.


29

2.6 Conjuntos universales Un conjunto de puertas o módulos combinacionales se llama conjunto universal si con él puedo implementar cualquier función de conmutación. Puesto que toda F.C. se puede expresar como la suma de los minitérminos que dan salida % 1, entonces necesitaremos siempre una puerta OR y un cierto número de puertas AND y NOT. Por lo tanto el conjunto {NOT, AND, OR} es universal. Además se demuestra que si nos falta la puerta AND o la puerta OR la podemos construir con las demás haciendo uso de las leyes de De Morgan: Para construir la puerta OR con NOTs y ANDs

Para construir la puerta OR con NOTs y ANDs

a! b%ab

ab % a ! b

Pero yo quiero a ! b por lo que, negando ambos términos de la ecuación: a ! b % a ! b % ab

Pero yo quiero ab por lo que, negando ambos términos de la ecuación: ab % ab % a ! b

Por lo tanto podemos decir que los conjuntos {NOT, AND} y {NOT, OR} son también conjuntos universales porque con ellos puedo implementar el conjunto {NOT, AND, OR} que es universal, es decir, que puedo implementar cualquier F.C. Podemos ver que la puerta OR se implementa con una puerta AND negada a la salida % NAND. Del mismo modo la puerta AND se implementa con una puerta OR negada a la salida % NOR. Por otro lado podemos construir una puerta NOT forzando la misma entrada en las dos bocas de una puerta NAND o NOR.

Si colocamos un negador, construido por mí a partir de puertas NAND, detrás de una NAND % AND. De este modo con una NAND puedo construir puertas NOT y AND r también puedo construir OR. Con las puertas NOR seguiría el mismo razonamiento.

30


Por lo tanto podemos decir que los conjuntos {NAND} y {NOR} son también conjuntos universales, ya que a partir de ellos puedo construir el conjunto {NOT, AND, OR} y por lo tanto implementar cualquier sistema combinacional.

2.7 Descodificadores Utilidad: Descodificar un número en binario a decimal. Implementar los 2n minitérminos posibles de una función de n variables. Funcionamiento:

2.8 Multiplexores o selectores (MUX) Utilidad: Seleccionar, de entre varias entradas, la que queremos que aparezca en la salida.


31

Funcionamiento:

Aplicación en la Implementación de Sistemas Combinacionales:

Implementación con MUX: Si queremos implementar una FC de n variables con un MUX. de m variables de control, siendo n b m: 1.

Pintar el MUX indicando los números de las puertas.

2.

Elegir m de las n variables. Estas m variables serán las variables de control. Situarlas en el MUX.

3.

Las m variables escogidas dividen el mapa de Karnaugh en zonas. Habrá 2m zonas, tantas como posibles combinaciones se pueden hacer con las m variables, negadas o sin negar.

4.

Para numerar cada zona sustituimos las variables negadas que la definen por ceros y las no negadas por unos. Después pasamos el número binario obtenido a decimal.

5.

Hacer rectángulos dentro de las zonas. Los rectángulos nunca podrán coger casillas de otra zona.

32


6.

A la hora de resolverlos aplicaremos las mismas reglas que para formar y simplificar rectángulos, pero eliminaremos de cada término producto aquellas variables que hemos decidido sean las de control.

Ejemplo:

Implementar la siguiente F.C. con un MUX de 4 a 1.

2.9 ROMS Utilidad: Implementar k funciones de conmutación de n variables.

Grabar 2n datos de ancho igual a k bits. Funcionamiento: Haciendo que las variables de las FC sean las líneas de dirección y grabando las FC en columnas implementamos hasta k FC distintas. También podemos grabar en filas hasta 2n datos de ancho k, que se direccionarán con las n líneas de dirección.


33

2.10 Otros módulos Codificadores Los codificadores realizan la operación inversa de los descodificadores: Toman un valor decimal y lo convierten en binario puro (sin signo). Para indicar el valor decimal situamos un 1 en la línea cuyo número sea el que queremos codificar. Un codificador tendrá, por tanto: 2n entradas y n salidas. Además habrá que añadir una entrada de Encendido y una salida de Activado, que se pondrá a 1 cuando alguna de las líneas de entrada tenga un 1. Los codificadores normales no permiten tener más de una línea de entrada levantada. Para evitar este problema podemos usar los codificadores con prioridad. En estos obtendremos el número binario equivalente al de la línea de entrada levantada más prioritaria. (La línea con el número más alto será la más prioritaria.) Los codificadores con prioridad son unos codificadores normales con un módulo a la entrada que resuelve las prioridades. PAL (Programable Array Logic) La PAL es una red de k puertas OR, m puertas AND y n puertas NOT. Las OR agrupan las puertas AND de un modo fijo. Nosotros conectamos las entradas de las puertas AND con los literales formando términos producto. De este modo lo que al final conseguimos implementar es k F.C. expresadas como suma de términos producto, de n variables cada una. Hay que tener en cuenta que tal vez no se puedan formar debido a que las conexiones de la matriz OR son fijas.

2.11 Problemas resueltos PROBLEMA 1 ¿Cuál de las afirmaciones es cierta? (Sólo hay una en cada caso.) a) x ! y %

ⵧ x ! y,

ⵧ x . y,

ⵧ x . y,

ⵧx.y

ⵧ x ! y,

ⵧ 0,

ⵧ1

ⵧ 1,

ⵧ x . z,

ⵧx!y!z

ⵧ y . z!x . y!z . x,

ⵧ xy!yz!xz

b) x ! y ! x %

ⵧ y, c)

z ! y ! x ! xz %

ⵧ 0, d)

f (x, y, z) % Gm(0, 2, 3, 6, 7) % ⵧ y ! (z . x), ⵧ z ! (y . x),

Solución: a) La solución es la tercera opción. Una de las leyes de DeMorgan es la equivalencia x ! y % x . y.

34


b) Aplicando las leyes de De Morgan primero y la propiedad distributiva de la suma después obtenemos la segunda opción: x ! y ! x % x ! (y . x) % (x ! y) . (x . x) % (x ! y) . 1 % x ! y c)

Operando obtenemos la tercera opción. z ! y ! x ! xz % z ! y ! x . xz % (z ! y ! x)(xz) % (z ! y . x)(xz) % %x.z. z!x . z. y. x%x . z!0%x. z

d) Resolviendo el mapa de Karnaugh se obtiene la primera opción.

PROBLEMA 2 Simplificar lo máximo posible la función f (x, y, z, w) % (z . (y ! w . x ! w . x)) . (x ! (z . w ! y)) Solución: f (x, y, z, w) % (z . (y ! w . x ! w . x)) . (x ! (z . w ! y)) % % z . (y ! w . x ! w . x) ! x (z . w ! y) % (z y ! zwx ! z w x) ! x(z . w ! y) % % z y ! zwx ! z w x ! xzw ! xy Llegados a este punto puede simplificar muy rápidamente si recurrimos a un mapa de Karnaugh. Introduciendo cada uno de los términos producto como rectángulos del mapa. De este modo tenemos:


35

Y la función simplificada es finalmente f (x, y, z, w) % xy ! zw ! yz PROBLEMA 3 Sea un sistema cuya entrada es un número en C2, codificado con 3 bits, y cuya salida es dicho número !3, también en C2 codificado con 3 bits. Además genera otra señal de error que da 1 cuando el resultado de la operación NO es representable con 3 bits. Se pide: Especificar dicho sistema mediante tablas de verdad e Implementar LA SEÑAL DE ERROR SOLO con puertas NAND. AYUDA: No hace falta usar mapas de Karnaugh.

Solución: Con 3 bits en C2 se puede codificar el intervalo de números enteros [.4, !3]. Por tanto el comportamiento del sistema viene descrito por la siguiente tabla: Alto Nivel

Binario

X

Z

X2

X1

X0

Z2

Z1

Z0

E

0 1 2 3 .4 .3 .2 .1

3 4 5 6 .1 0 1 2

0 0 0 0 1 1 1 1

0 0 1 1 0 0 1 1

0 1 0 1 0 1 0 1

0 x x x 1 0 0 0

1 x x x 1 0 0 1

1 x x x 1 0 1 0

0 1 1 1 0 0 0 0

donde se ha marcado con x aquellas salidas que se dejan indeterminadas ya que producen un error. La EC de la señal de error E es E % Gm(1, 2, 3). Por tanto su diseño con una red de puertas NAND es la mostrada en la figura.

36


PROBLEMA 4 Simplificar lo más posible la E.C. w .x .y!w .x. y!w. z.x!z. y e implementar la ecuación simplificada usando ÚNICAMENTE puertas NAND. Solución: Puesto que la EC es una suma de productos, cada término producto será un rectángulo del mapa de Karnaugh de 4 variables. Así, resolviendo el mapa de Karnaugh podemos encontrar la suma de productos más simplificada posible.

Resolviendo el mapa tenemos: f (x, y, z, w) % x . y ! x . y . z ! x . y . w ! x . z . w, que implementado con puertas NAND sería:


37

PROBLEMA 5 Sea la F.C: f % Gm(0, 2, 7, 8, 12, 13) ! Gd(3, 10, 11, 14). Encontrar su expresión más simplificada e implementarla usando únicamente puertas NAND. Solución:

Resolviendo el mapa, tenemos: f (x3, x2, x1, x0) % x2 x1 x0 ! x3 x2 x1 ! x2 x1 ! x3 x1 x0 cuya implementación con puertas NAND es:

38


PROBLEMA 6 Dada la siguiente tabla de verdad se pide: a) b) c) d) e)

Representar la EC de cada salida como Suma de Productos Canónica. Implementar todo el sistema con 1 descodificador y puertas. Implementar la salida U con el menor número de puertas NAND. Implementar la salida V con un único MUX. Implementar la salida W con MUXs de 4 a 1. A

B

C

D

U

V

W

0

0

0

0

1

0

0

0

0

0

1

1

1

1

0

0

1

0

0

0

0

0

0

1

1

1

1

0

0

1

0

0

0

1

1

0

1

0

1

1

0

X

0

1

1

0

0

1

1

0

1

1

1

X

X

0

1

0

0

0

X

X

0

1

0

0

1

0

X

X

1

0

1

0

0

0

0

1

0

1

1

1

1

0

1

1

0

0

0

1

1

1

1

0

1

1

0

0

1

1

1

0

1

1

X

1

1

1

1

X

X

1


Solución: a) U(A, B, C, D) % Gm(0, 1, 3, 5, 11, 13, 14) ! Gd(7, 8, 15) V(A, B, C, D) % Gm(1, 3, 4, 6, 11, 12, 14) ! Gd(7, 8, 9, 15) W(A, B, C, D) % Gm(1, 4, 6, 12, 15) ! Gd(5, 9, 14) b) Necesitaremos un descodificador de 4 a 16 y 3 puertas OR, una por cada FC.

c)

Resolviendo el mapa de Karnaugh para U tenemos:

39

40


X(A, B, C, C) % A . B . C ! A . B . C ! B . D ! C . D

d) Usando un MUX de 16 a 1 la implementación es inmediata. Los minitérminos que están sin especificar se han tomado como cero.

e)

Para implementar W con un MUX de 4 a 1 es necesario seleccionar dos variables de control. Eligiendo A y B obtenemos una implementación mínima,


PROBLEMA 7 Dado el siguiente sistema combinacional, se pide averiguar si es un conjunto universal. NOTA: Todos los multiplexores están capacitados.

41

42


Solución: Dado que el sistema tiene sólo dos entradas el modo más rápido de abordar este problema es completar la tabla de verdad. Llamando T1 a la salida del Mux de arriba y T0 a la salida del MUX de abajo, tenemos: X1

X0

T1

T0

Z

0 0 1 1

0 1 0 1

0 0 1 1

0 1 0 1

1 0 1 0

El sistema no es conjunto universal porque Z es, en definitiva, la entrada X0 negada. Por tanto es imposible construir una puerta AND o una puerta OR. PROBLEMA 8 Sea una puerta combinacional con la Tabla de verdad de la derecha. ¿Para qué valores de a y b podemos decir que la puerta es un conjunto universal? ¿Por qué? X

Y

Salida

0 0 1 1

0 1 0 1

0 a b 1

Solución: Hay 4 posibilidades que dan lugar a los 4 sistemas diferentes mostrados en la tabla: X

Y

S0

S1

S2

S3

0 0 1 1

0 1 0 1

0 0 0 1

0 0 1 1

0 1 0 1

0 1 1 1

El sistema S0 es una puerta OR, por tanto no es conjunto universal. El sistema S1 es X, por lo que tampoco puede ser conjunto universal. El sistema S2 es Y, por tanto, al igual que con S1, no puede ser conjunto universal. El sistema S3 es una puerta AND, de modo que tampoco es conjunto universal. En definitiva ninguno de los 4 es conjunto universal.


43

PROBLEMA 9 Analizar el sistema y razonar si es conjunto universal.

Solución: Lo primero es analizar el circuito. Para simplificar esta tarea es recomendable sustituir la puerta NAND del nivel 1 por una puerta OR con las entradas negadas, que es la implementación equivalente tal y como dictan las leyes de DeMorgan. Una vez hecho esto dos negadores enfrentados en el mismo cable se anulan tal y como muestra la figura. Finalmente se procede a calcular la EC de F.

T1 % X . Y T2 % X . Y T3 % T1 ! T2 % X . Y ! X . Y % (X ! X)Y % (1)Y % Y T4 % X . Z F % T3 ! T4 % Y ! X . Z El sistema es equivalente a bloque combinacional que tuviera 3 entradas (X, Y, Z) y una salida F con la ecuación obtenida. Podemos construir un conjunto universal si forzamos la entrada Y % 0. De este modo tendríamos F % X . Z % X ! Z, es decir un bloque equivalente a una puerta NOR. Puesto que la puerta NOR es conjunto universal y ésta se puede construir con el circuito dado, éste también es conjunto universal.

44


PROBLEMA 10 Dado el sistema de la figura, construir una puerta AND a partir de él. ¿Es conjunto universal?¿Por qué?

Solución: La ecuación de un MUX 2 a 1 es sencillamente Z % D0S ! D1S, donde D0 y D1 son las entradas de datos conectadas a la entrada 0 y 1 respectivamente y S es el bit de selección. Por tanto sustituyendo tenemos: D0 % X . Y ! Y % X ! Y ! Y % X ! 1 % 1 D1 % Y S%X Z % (1)X ! (Y)X % X ! YX Z aún se puede simplificar más. Usando el mapa de Karnaugh se obtiene finalmente que Z%X!Y%X .Y 1 X

1

1 Y

Por tanto el circuito es equivalente a una puerta NAND, que es conjunto universal. Por tanto el circuito dado también lo es. Si forzamos la entrada Y % 1 entonces Z % X ! 1 % X ! 0 % X; es decir habremos construido una puerta NOT. Para construir la puerta AND basta con conectar la puerta NOT que acabamos de construir a la salida del circuito dado tal y como muestra la figura.


45

PROBLEMA 11 Analiza el circuito y da su expresión de conmutación: a) Como suma de productos canónica. b) Como suma de productos lo más simplificada posible. c)

¿Es conjunto universal? Justifica la respuesta.

Solución: a) Para analizar este sistema conviene transformarlo primero en el equivalente que se muestra a continuación.

b) T1 % AC T2 % CB T3 % AC T4 % T1 ! T2 ! T3 % AC ! CB ! AC % A(C ! C) ! CB % A ! CB T5 % T3 ! B % AC ! B f % T4A ! T5A % (AC ! B)A ! (AC ! B)A % A B ! AC ! AB % AC ! B c)

El sistema es un conjunto universal porque podemos construir una puerta NAND de dos entradas si hacemos que la entrada A tome el valor 1. De este modo f % AC ! B % C ! B % C . B, donde se ha aplicado la Ley de DeMoore. Puesto que la puerta NAND es conjunto universal, una vez construida podríamos implementar cualquier sistema combinacional y por tanto también es conjunto universal.

46


Para encontrar la suma de productos canónica podemos introducir la suma de productos obtenida en un mapa de Karnaugh de 4 variables y observar aquellas casillas que toman valor 1. Por tanto la suma de productos canónica es: f (A, B, C) % Gm(0, 1, 4, 5, 6) F1

C

A

1

1

1

1

1 B

PROBLEMA 12 Sea el sistema de la figura, donde el módulo M da salida 1 cuando en la entrada hay dos ceros o dos unos adyacentes, leyendo las entradas de arriba abajo (o sea A-B-C). Calcular la suma de productos más simplificada de F1 y F2.

Solución: Para resolverlo es necesario encontrar primero la FC del módulo M. Puesto que sólo tiene 3 entradas, el modo más rápido y directo es hacer la tabla de verdad. A

B

C

M

F1

F2

0 0 0 0

0 0 1 1

0 1 0 1

1 1 0 1

1 1 0 1

1 1 0 0

1 1 1 1

0 0 1 1

0 1 0 1

1 0 1 1

0 0 0 0

1 0 0 0

Para calcular la suma de productos más simplificada posible de F1 y F2 hay que resolver los siguientes mapas de Karnaugh:


47

Las expresiones son: F1(A, B, C) % A . B ! A . C

F2(A, B, C) % A . B ! B . C

y

PROBLEMA 13 Sea un sistema P con la tabla de verdad dada. ¿Para qué valores de a y b dicho sistema es conjunto universal? Razona las respuestas. X

Y

P

0

0

a

0

1

b

1

0

1

1

1

0

Solución: Hay 4 posibilidades que dan lugar a los 4 sistemas diferentes mostrados en la tabla: X

Y

P0

P1

P2

P3

0 0 1 1

0 1 0 1

0 0 1 0

0 1 1 0

1 0 1 0

1 1 1 0

El sistema P1 es una puerta XOR, con la que nunca podremos construir puertas OR ni AND, por lo tanto no es conjunto universal. El sistema P2 es la negación de Y, por tanto, al igual que P1, no puede ser conjunto universal. El sistema P3 es una puerta NAND, de la cual sabemos que sí es conjunto universal. El sistema P0 tiene la siguiente EC. P0(X, Y) % XY Forzando X % 1 podemos construir un negador.

48


Una vez tenemos el negador podemos construir la puerta AND de dos entradas A y B del siguiente modo:

En definitiva, podemos construir tanto puertas AND como puertas NOT utilizando sólo el sistema P0. Puesto que con el conjunto {AND, NOT} se puede implementar cualquier sistema combinacional, el sistema P0 es conjunto universal. PROBLEMA 14 Una avioneta tiene 2 luces de seguridad: {Peligro, Emergencia}. La luz de Peligro se encenderá si ocurre alguno de estos casos: – Altura menor de 1000 pies, sin sistema de navegación y sin visibilidad. – Altura mayor de 1000 pies y fallo del motor. – Altura mayor de 1000 pies y no hay visibilidad. La luz de Emergencia se encenderá si ocurre alguno de estos otros casos: – Altura menor de 1000 pies y fallo del motor. – Altura mayor de 1000 pies, sin sistema de navegación y sin visibilidad. – Altura mayor de 1000 pies, sin sistema de navegación y fallo del motor. Dar una descripción de alto nivel y especificar claramente cómo se codifican los datos del problema. Diseñar el sistema que gobierna la luz de Peligro usando SOLO MUX de 4 a 1. Diseñar el sistema que gobierna la luz de Emergencia usando descodificadores y puertas. ¿En qué casos se encenderán ambas luces? Solución: En primer lugar se codifica el problema con variables binarias. Una posibilidad (no la única) es la siguiente: Variable

Significado

Codificación

Descodificación

M N V A

Fallo de motor Fallo del sistema de navegación Visibilidad Altura superior a 1.000 pies

0/1 0/1 0/1 0/1

No/Sí hay fallo No/Sí hay fallo No/Sí hay No/Sí


49

Entonces las condiciones para encender la luz de peligro (P) y emergencia (E) son: P%A . N.V!A . M!A . V E%A . M!A .N .V!A . N.M Para expresar P y E como suma de productos canónica introducimos los términos producto en mapas de Karnaugh y de este modo aparecerán los minitérminos que dan salida 1. El orden en el que se coloquen las variables en el mapa de Karnaugh no importa, pero una vez elegido se debe mantener hasta el final del ejercicio.

E % Gm(1, 3, 5, 7, 9, 11, 12, 13) P % Gm(4, 5, 8, 9, 11, 12, 13, 15) Para implementar con MUX de 4 a 1 la luz P se toman como variables de control S1 % A y S0 % V de modo que:

50


La ecuación para encender ambas luces es (P)AND(E) % Gm(5, 9, 11, 12, 13), que simplificando resulta:

(P)AND(E) % A . N . V ! A . M . N ! N . M . V, es decir si la altura es mayor de 1000 pies, falla la navegación y no hay visibilidad o si la altura es mayor de 1000 pies, falla el motor y no falla la navegación y si no hay visibilidad, falla la navegación y falla el motor. PROBLEMA 15 El ángulo de inclinación de la cola de un caza se clasifica según el gráfico, donde los números son las decenas de grado. Queremos diseñar un sistema que activará el traje anti-G y encenderá la alarma del caza según el ángulo de inclinación. La alarma se encenderá cuando haya inclinación de vulnerabilidad y de bajada; y se apagará en los demás casos. El traje anti-G soló se activará cuando la inclinación sea de pérdida o de máximo esfuerzo. El sistema debe recibir las decenas de grado, con su correspondiente signo, codificadas en C2.


51

a) Dar la tabla de verdad del sistema. b) Implementar la señal Alarma usando sólo MUXs de 4 a 1. c)

Implementar la señal Anti-G usando sólo las puertas NAND imprescindibles.

Solución: Codificación: El ángulo de inclinación varía desde .7 hasta !7. Usando notación C2 necesitaríamos 4 bits para codificar la información. Dependiendo de dicho ángulo se activa o desactiva la señal de alarma y el traje anti-G. Son por tanto dos salidas binarias A y G sobre las que se toma el siguiente convenio: A % 1: Encender alarma,

A % 0: Apagar alarma

G % 1: Activar antiG,

G % 0: Desactivar antiG

Se obtendría entonces la siguiente tabla: Ángulo

Código

.7 o menor

1001

.6

1010

.5

1011

.4

1100

.3

Régimen de inclinación

A

G

0

1

0

1

0

0

0

0

1101

0

0

.2

1110

1

0

.1

1111

1

0

0

0000

1

0

1

0001

1

0

2

0010

1

0

3

0011

1

0

4

0100

1

0

5

0101

1

0

6

0110

0

1

0

1

Máximo esfuerzo

Subida

Vulnerabilidad

Bajada

Pérdida 7 o mayor

0111

Para trabajar es más conveniente escribir la tabla de verdad en el orden habitual, comenzando por el minitérmino 0 y acabando en el 15.

52


Ángulo

Código

A

G

0 1 2 3

0000 0001 0010 0011

1 1 1 1

0 0 0 0

4 5 6 7

0100 0101 0110 0111

1 1 0 0

0 0 1 1

.7 .6 .5

1000 1001 1010 1011

* 0 0 0

* 1 1 0

.4 .3 .2 .1

1100 1101 1110 1111

0 0 1 1

0 0 0 0

Esto ha facilitado detectar un caso que no había sido contemplado. El (1000)C2 se corresponde con el .8. Según la codificación inicial, en la que el (1001)C2 codifica ángulos menores o iguales a .70o este caso no se daría nunca y por tanto la mejor opción sería dejar dicho minitérmino sin especificar (*). Para implementar la señal A con un MUX de 4 a 1 es necesario resolver un mapa de Karnaugh. Por la disposición de los minitérminos que dan salida 1, la elección de X3 y X2 (los dos bits más significativos de la entrada) logra una de las implementaciones más sencillas.

Puesto que se exige utilizar sólo MUX de 4 a 1, para implementar la FC es necesario construir un negador con un MUX de 4 a 1.


53

Para implementar la señal Anti-G con puertas NAND de nuevo es necesario resolver un mapa de Karnaugh. La suma de términos producto más simplificada es entonces: G(X2, X2, X1, X0) % X3 X2 X1 ! X3 X2 X1 ! X3 X2 X0

PROBLEMA 16 Se quiere diseñar un sistema de limitación de velocidad de un buque gobernado por los parámetros de Estado de la mar y Sentido de la marcha. El sistema da tres posibles límites: 20 nudos: cuando el buque se mueve hacia atrás o cuando la mar está encrespada. 30 nudos: cuando el buque se mueve hacia delante y el estado de la mar sea agitada. 40 nudos: del resto de los casos, cuando la mar esté en calma. a) Dar una descripción del número de entradas y salidas del sistema y una codificación. b) Implementar las salidas usando únicamente puertas NAND. Añadimos ahora un sistema que toma la velocidad real del buque (20, 30 o 40 nudos), la compara con la permitida y emite una señal de peligro cuando la velocidad real es superior. c)

Implementar este último sistema usando un único MUX de 8 a 1 y negadores.

(Hay varias posibilidades para codificar el problema.)

54


Solución: Codificación: El sistema de limitación será un sistema combinacional con 2 salidas binarias con las que se codifican los tres posibles límites de velocidad: L1L0 % 00: 20 nudos ; L1L0 % 01: 30 nudos ;

L1L0 % 10: 40 nudos

Las entradas del sistema son: Estado de la mar (E) y Sentido de la marcha (S) sobre las que se toma el siguiente convenio: E1E0 % 00: Calma ; E1E0 % 01: Agitada E1E0 % 10: Encrespada ; S % 0/1: Atras/Adelante En definitiva el sistema tiene 3 entradas y 2 salidas y por tanto un modo fácil de abordar el problema es utilizar la tabla de verdad, cuya cabecera sería: E1

E0

S

L1

L0

El procedimiento es completar el lado derecho con todas las posibilidades y codificar cada uno de los casos con el límite de velocidad correspondiente según las especificaciones. E1

E0

S

L1

L0

0 0 0 0

0 0 1 1

0 1 0 1

0 1 0 0

0 0 0 1

1 1 1 1

0 0 1 1

0 1 0 1

0 0 X X

0 0 X X

Los casos 110 y 111 han quedado sin especificar porque no existe ningún estado de la mar con código 11 y por tanto nunca ocurrirán. Para implementar L1 y L0 no hace falta resolver ningún mapa de Karnaugh puesto que sólo hay un minitérmino que da salida 1 para cada caso. Es decir: L1 % Gm(1)

y

L0 % Gm(3)

Con puertas NAND tendríamos el siguiente diseño:


55

El sistema de seguridad que avisa cuando la velocidad real es superior a la permitida tiene por un lado la entrada del límite de velocidad en cada caso (L1L0) y por otro la velocidad real del buque. Codificando con 2 bits la velocidad real del siguiente modo: V1V0 % 00: 20 nudos

; V1V0 % 01: 30 nudos ;

V1V0 % 10: 40 nudos

entonces la señal de Peligro se activará (P % 1) según la siguiente tabla de verdad: L1

L0

V1

V0

P

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

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

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

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

0 1 1 X 0 0 1 X 0 0 0 X X X X X

Para implementar la salida P con un único MUX de 8 a 1 es necesario elegir 3 variables de control. Tomando L1, L0 y V1 conseguimos una implementación mínima y ni siquiera es necesario utilizar negadores.

56


PROBLEMA 17 Diseñar un sistema, S, que abre 2 válvulas, V1 y V0, mezclando dos medicinas, A y B. La válvula V1 se abrirá siempre que el paciente tenga menos de 40 pulsaciones y fallo renal o entre 40 y 90 pulsaciones y fallo respiratorio o si tiene más de 90 pulsaciones. La válvula V0 se abrirá cuando el paciente tenga menos de 40 pulsaciones o cuando tenga más de 90 pulsaciones y fallo respiratorio y renal. Se pide: a) Hacer una codificación y dar la tabla de verdad del sistema y la E.C. más simplificada de V1 y V0. b) Diseñar el sistema usando un descodificador y puertas. c)

Implementar la F.C. de V1 con MUXs de 8 a 1 y la F.C. de V0 con MUXs de 4 a 1. (Las únicas puertas que se pueden usar en este apartado son las NOT.)

d) Se añade un sensor a cada botella que se activa cuando ésta se encuentra vacía. Diseñar un sistema, al que se conectan 5 botellas, que detecte cuándo hay más botellas vacías que llenas.

Solución: En primer lugar se codifica el problema con variables binarias. Una posibilidad (no la única) es la siguiente: Variable

Significado

Codificación

Descodificación

P1, P0 R T

Pulsaciones Fallo renal Fallo respiratorio

00/01/10 0/1 0/1

Menos de 40/Entre 40 y 90/Más de 90 No/Sí hay fallo No/Sí hay fallo

Las expresiones de conmutación para las válvulas V1 y V0, según las especificaciones dadas, son: V1 % P1P0 R ! P1P0 T ! P1P0

y

V 0 % P 1P 0 ! P 1P 0 R

Para implementar el sistema S con un descodificador y puertas es necesario conocer la Suma de Productos Canónica (SPC). Puesto que tenemos las EC de las válvulas como suma de productos, podemos trasladar cada término producto a un mapa de Karnaugh.


57

Por tanto las SPC de las válvulas son: V1(P1, P0, R, T) % Gm(2, 3, 5, 7, 8, 9, 10, 11)

y

V0(P1, P0, R, T) % Gm(0, 1, 2, 3, 10, 11)

El diseño con descodificadores es ahora inmediato:

Para implementar V1 con un MUX de 8 a 1 se elige P1, P0 y R como variables de selección del MUX. Otra elección diferente no simplificaría el diseño. De este modo el mapa de Karnaugh se divide en 8 zonas con las siguientes EC: F0 % 0, F1 % 1, F2 % T, F3 % T, F4 % 1, F5 % 1, F6 % 1, F7 % 0

58


Para implementar V0 con un MUX de 4 a 1 se eligen P1 y P0 como variables de selección. Ahora el mapa de Karnaugh se divide en 4 zonas con las siguientes EC: F0 % 1,

F1 % 0,

F2 % R

y

F3 % 0

Por último, para diseñar el sistema que detecta cuándo hay más botellas vacías que llenas, dado que se conecta a 5 sensores se podría recurrir a una tabla de verdad de 32 filas e implementarla posteriormente con alguno de los métodos que se conocen. Este procedimiento ya no es eficaz si hubiera más sensores pues por cada sensor que se añadiera la tabla duplicaría su tamaño. Esta solución queda propuesta. Una alternativa, que es válida para cualquier número de sensores, es averiguar cuántos hay activos sumándolos y comparando después el número obtenido con la mitad de los sensores conectados. Para ello es importante darse cuenta de que un sumador se puede ver como un sistema que devuelve (en binario) el número de unos a la entrada. Es decir, si recibe dos entradas binarias A y B, el número N formado por el carry Cout y la salida S indica si hay 0, 1 o 2 unos entre A y B.


59

Dispongamos entonces los 5 sensores: A, B, C, D y E en parejas que se conectan a sumadores. Puesto que tenemos un número impar, el sensor E se empareja con un cero.

NAB, NCD y NE son 3 números binarios de dos bits. El siguiente paso es añadir una nueva capa de sumadores, ahora de 2 bits, para sumar NAB con NCD y NE con 0. Finalmente una nueva capa con un sumador de 3 bits obtendríamos 4 bits que forman el número binario N % (N3N2N1N0)2 que se corresponde con el total de unos que hay en las entradas. Este dispositivo sería capaz de contar desde 0 hasta 8 unos en caso de que se utilizaran sus 8 entradas.

Cuando N sea mayor o igual que 3 se debe activar el detector de más botellas vacías que llenas. Teniendo en cuenta que el número N nunca será mayor que 5 se plantea el siguiente mapa de Karnaugh que da lugar a la EC del detector: Detector % N2 ! N1N0.

60


Con todo el circuito detector es el siguiente:

PROBLEMA 18 Para transmitir información numérica en estaciones de esquí se colocan 5 luces en un disco elevado 3 metros por un poste y se establece el código de la figura, donde el círculo oscuro significa que está encendido. Diseñar un sistema que conste de un teclado, el poste de luces y un subsistema que transforma la información del teclado en luces encendidas y apagadas en el poste. a) Explica claramente los módulos que se utilizan y la codificación elegida. b) Utiliza descodificadores y puertas OR para implementar las luces A, B y C. c)

Utiliza el menor número posible de MUXs de 4 a 1 para implementar las luces D y E.


61

Solución: La tabla de verdad del sistema que enciende y apaga las luces es: N3

N2

N1

N0

A

B

C

D

E

0 0 0 0

0 0 0 0

0 0 1 1

0 1 0 1

0 1 1 1

1 0 0 1

0 0 1 1

0 0 0 0

1 0 0 0

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

1 1 1 0

1 1 1 1

1 1 0 1

1 1 0 0

0 1 0 0

1 1 1 1

0 0 0 0

0 0 1 1

0 1 0 1

0 0 X X

0 0 X X

1 0 X X

1 1 X X

0 1 X X

1 1 1 1

1 1 1 1

0 0 1 1

0 1 0 1

X X X X

X X X X

X X X X

X X X X

X X X X

La implementación con descodificadores y puertas OR es inmediata.

Para implementar D y E con MUX de 4 a 1 es necesario elegir 2 variables de control y resolver el mapa de Karnaugh. Eligiendo N3 y N2 tenemos una implementación mínima para D y para E.

62


El resultado es el siguiente:

Es interesante resaltar que puesto que no se permite utilizar otro elemento combinacional, las expresiones de conmutación F0 y F1 del MUX que implementa E se deben implementar a su vez con otro MUX de 4 a 1. Esto no es difícil ya que ambas son FC de dos variables (N1 y N0) y por tanto basta con colocar sus funciones de conmutación en la entrada de datos. Igualmente para la expresión de conmutación F1 del MUX que implementa D es necesario construir un negador con un MUX de 4 a 1. En definitiva:


63

PROBLEMA 19 Dar las ecuaciones y los circuitos, con los elementos combinacionales que prefieras, de una red iterativa que reciba y genere n bits y funcione del siguiente modo: zi %

E

1 si (xi % 1) p (xi.1 % 0) p (xi.2 % 1) 0 en otro caso

Es decir, una celda da salida % 1 cada vez que detecta una ventana con el 101. El siguiente gráfico representa una red de 8 celdas como la que se desea diseñar, donde se puede apreciar un ejemplo de funcionamiento para una cierta entrada. Los recuadros son las celdas y el número inscrito es su índice.

Solución: La red iterativa se compone de n celdas, cada una de las cuales recibe un bit Xi y genera un bit Zi. Para que la red funcione, además es necesario que cada celda transmita a la siguiente (la que se encuentra a su izquierda) la información que resume todo lo que ha ocurrido en las celdas anteriores (las de la derecha) más la información que recibe la propia celda.

64


Esta información se codifica con 2 bits del siguiente modo: Significado

A

B

Ninguno de los siguientes Xi % 1 Xi % 0 p Xi.1 % 1

0 0 1

0 1 0

La red iterativa tendrá entonces el siguiente aspecto:

Y, según la codificación dada, la celda genérica i tendrá el siguiente esquema y tabla de verdad. Xi

Ai

Bi

Zi

Ai!1

Bi!1

0 0 0 0

0 0 1 1

0 1 0 1

0 0 0 X

0 1 0 X

0 0 0 X

1 1 1 1

0 0 1 1

0 1 0 1

0 0 1 X

0 0 0 X

1 1 0 X

Para la implementación simplificamos las FC de Zi, Ai!1 y Bi!1.


65

Por último, para que la red funcione correctamente, es necesario que A0 % 0 y B0 % 0. PROBLEMA 20 Diseña un multiplexor de 4 a 1 usando un descodificador de 2 a 4 y puertas. Solución: Para resolverlo basta recordar que un multiplexor es un sistema que contiene todos los minitérminos que se pueden formar con las entradas de selección multiplicados a su vez por su entrada de datos correspondiente; y que un descodificador es un sistema que contiene todos los minitérminos que se pueden formar con las entradas de datos. Por tanto habrá que multiplicar cada una de las salidas del descodificador por la entrada correspondiente de datos. Finalmente todas las salidas se deben sumar. Llamando {S1, S0} a las entradas de selección E a la capacitación y {X3, X2, X1, X0} a las entradas de datos, el MUX de 4 a 1 se construiría como muestra la figura.

66


PROBLEMA 21 Se ha diseñado un sistema de visión artificial capaz de distinguir accesos en una pared. Para probarlo se integra en un robot motorizado y se construye un laberinto de habitaciones triangulares tal que cada una de las paredes puede tener o no un acceso. Cuando el sistema de visión identifica un acceso lo etiqueta según esté en la pared de la izquierda (a) o de la derecha (b). Diseñar el sistema que gobierna los movimientos del robot en función de los accesos que «ve» en una habitación al entrar; teniendo en cuenta que se quiere construir con el menor número de circuitos 7400, que contienen 4 puertas NAND de 2 entradas. El robot recorrerá el laberinto del siguiente modo: – Si llega a una habitación y no ve accesos, debe retroceder. – Si llega a una habitación y ve 1 acceso debe avanzar (hacia la izquierda o la derecha) para salir por el que no entró. – Si llega a una habitación y ve 2 accesos debe avanzar para salir siempre por la derecha. En la figura se muestra una habitación con 3 accesos (a y b más el acceso por el que ha entrado), tal como la vería el robot.

Solución: El robot tiene 3 posibles movimientos: {retroceder, ir a la izquierda, ir a la derecha} El movimiento se decide en función del número de accesos que ve y tiene 4 posiblidades: {ninguno, uno a la derecha (b), uno a la izquierda (a), uno a cada lado (a y b)} Por tanto habrá que codificar con 2 bits (A y B) la entrada (accesos vistos) y con 2 bits (M1 y M0) la salida (movimientos). Se propone la siguiente codificación: Accesos vistos

A

B

Movimiento

M1

M0

Ninguno Uno a la derecha Uno a la izquierda Uno a cada lado

0 0 1 1

0 1 0 1

Retroceder Derecha Izquierda

0 0 1

0 1 0


67

La tabla de verdad del sistema será sencillamente: A

B

M1

M0

0 0 1 1

0 1 0 1

0 0 1 0

0 1 0 1

Las EC de M1 y M0 son M1 % AB y M0 % B.

PROBLEMA 22 Se quiere construir un sistema de control de movimiento de una plataforma en la que se monta una cámara. La plataforma se maneja a distancia por radio a través de un mando (ver figura) y que funciona del siguiente modo: La rueda con 3 posiciones excluyentes {I, N, D} maneja el giro de la cámara del siguiente modo: — En en el sentido de las agujas del reloj si la rueda se lleva a D. — En el sentido contrario a las agujas del reloj si la rueda se lleva a I. — No gira si la rueda se lleva a N. La rueda con 3 posiciones excluyentes {R, N, A} maneja el giro del brazo que sujeta la cámara del siguiente modo: — Hacia delante si la rueda se lleva a A. — Hacia detrás si la rueda se lleva a R. — Se detiene si la rueda se lleva a N. En la plataforma tanto el brazo como la cámara tienen, cada uno, un pequeño motor con 8 posibles funcionalidades diferentes. A nosotros sólo nos interesan las siguientes: — Detener movimiento % código 110. — Girar en sentido de las agujas del reloj % código 001. — Girar en sentido contrario a las agujas del reloj % código 011. El mando envía la información acerca de la posición de las ruedas y además añade un bit de paridad tal que el número de ceros que se transmitan sea siempre IMPAR. El robot recibe la información y genera los bits necesarios para que se muevan los motores del brazo y de la cámara.

68


a) Hacer una codificación completa, tanto del mando como de la plataforma, y dar las tablas de verdad de ambos. b) Implementar el bit de paridad con un descodificador y puertas. c)

Implementar el movimiento del motor del brazo sólo con MUXs de 2 a 1.

d) Implementar el movimiento del motor de la plataforma sólo con MUXs a elegir. NOTA: El mando tiene varios canales por lo que emite todos los bits al mismo tiempo y la plataforma los recibe al mismo tiempo.

Solución: El mando tiene 2 ruedas con 3 posiciones por lo que cada rueda se debe codificar con 2 bits Cámara

C1

C0

Brazo

B1

B0

N D I

0 0 1

0 1 0

N A R

0 0 1

0 1 0

La rueda «Cámara» gobierna el motor MC en la plataforma que sostiene la cámara y que sirve para girar en el eje vertical, mientras que la rueda «Brazo» gobierna el motor MB de dicha plataforma, que sirve para girar en el eje horizontal. Tenemos que decidir cómo colocar los motores MC y MB para que al girar funcionen como se pide. Se propone lo siguiente: Sentido de giro

MC

MB

Código

Horario Antihorario Detener

D I N

A R N

001 011 110

De este modo se obtendrían las siguientes tablas de verdad: Código MC C1

C0

MC2

MC1

0 0 1 1

0 1 0 1

1 0 0 X

1 0 1 X

Código MB

MC0

B1

B0

MB2

MB1

MB0

0 1 1 X

0 0 1 1

0 1 0 1

1 0 0 X

1 0 1 X

0 1 1 X


69

Gracias a la adecuada elección de la posición de los motores ambas tablas de verdad son idénticas, lo que falicita la tarea. El bit de paridad P se genera con la posición de ambas ruedas según la siguiente tabla de verdad y su implementación se muestra en la figura. C1

C0

B1

B0

P

0 0 0 0

0 0 0 0

0 0 1 1

0 1 0 1

1 0 0 1

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

0 1 1 0

1 1 1 1

0 0 0 0

0 0 1 1

0 1 0 1

0 1 1 0

1 1 1 1

1 1 1 1

0 0 1 1

0 1 0 1

1 0 0 1

70


Para implementar el movimiento del brazo necesito generar los bits del código correspondiente a partir de las entradas B1 y B0. Además se pide hacerlo con MUX de 2 a 1 por lo que se deben calcular las funciones de conmutación con los mapas de Karnaugh.

Para implementar el movimiento de la cámara se eligen MUXs de 4 a 1 pues así no es necesario realizar ningún cálculo. Los valores indeterminados se tomaron como 0. El resultado es:


71

2.12 Problemas propuestos PROBLEMA 1 Implementar las siguientes funciones de conmutación con el menor número de puertas NAND: F1(x3, x2, x1, x0) % Gm(0, 2, 4, 8, 9, 10, 11, 12, 14, 15) F0(x3, x2, x1, x0) % x3 x0 ! x3 x2 x0 ! x3 . x2 . x0 ! x3 . x1 PROBLEMA 2 Se quiere construir un sitema de control de movimiento de un robot en el que se monta un sistema de visión artificial. El robot se maneja por radiofrecuencia con un mando de 1 palanca con 4 posiciones excluyentes {Neutro, Adelante (A), Izquierda (I) y Derecha (D)} y un botón Reverse (R). Cuando R no esta apretado el robot se mueve del siguiente modo: – En línea recta mientras se lleva la palanca hacia A. – Hacia la izquierda mientras se lleva la palanca hacia I. – Hacia la derecha mientras se lleva la palanca hacia D. Cuando R está apretado el robot se mueve hacia detrás, del mismo modo que lo hacía hacia delante. Las ruedas de delante del robot puden estar detenidas, moverse hacia delante o moverse hacia detras. — Para avanzar recto (tanto hacia delante como hacia detrás) se deben mover ambas en el mismo sentido. — Para avanzar a la derecha se debe mover (adelante o atrás) la rueda izquierda y detener la derecha. — Para avanzar a la izquierda se debe mover (adelante o atrás) la rueda derecha y detener la izquierda. El mando envía la información acerca de la posición de la palanca y el botón R y además añade un bit de paridad tal que el número de unos que se transmitan sea siempre PAR. El robot recibe la información y genera el movimiento que tiene que realizar la rueda izquierda y derecha. a) Hacer una codificación completa, tanto del mando como del robot, y dar las tablas de verdad. b) Implementar el bit de paridad con un único MUX. c)

Implementar el movimiento de las ruedas con un descodificador y puertas OR.

d) Implementar de nuevo el movimiento de las ruedas sólo con MUX de 4 a 1 y NOT. NOTA: El mando tiene varios canales por lo que emite todos los bits al mismo tiempo y la plataforma los recibe al mismo tiempo.

72


PROBLEMA 3 Una pequeña tienda de música quiere un aparato que le avise de cuándo hay que llamar al proveedor. El aparato tiene 4 botones con los que codifica la siguiente información: – Se ha vendido al menos el 20% de las existencias de Springsteen. – Se ha vendido al menos el 30% de las existencias de Elton John. – Se ha vendido al menos el 40% de las existencias de Garth Brooks. – Se ha vendido al menos el 50% de las existencias de la tienda. Queremos avisar al proveedor cuando ocurra alguno de estos casos: – Se ha vendido el 20% de S. , menos del 30% de E. y el 50% de la tienda. – Se ha vendido más del 30% de E. y más del 50% de la tienda. – Se ha vendido al menos el 40% de G. y más del 50% de la tienda. – Se ha vendido menos del 20% de S. Dar la tabla de verdad del sistema y diseñarlo usando MUX de 4 a 1 y puertas. PROBLEMA 4 Sea un sistema digital con dos entradas y dos salidas. Las entradas son: X % número, en convenio C1 o C2, codificado con 3 bits. C % {0, 1} Y las salidas son: Z1 % 1 si ((X)C2 ! C)10 es PAR; y 0 en caso contrario. Z0 % 1 si ((X)C1 ! C)10 es IMPAR; y 0 en caso contrario. Se pide: a) Dar una especificación de alto nivel. b) Hacer la tabla de verdad de Z1(C, x2, x1, x0) y Z0(C, x2, x1, x0). c)

Implementar Z1 usando MUX de 8 a 1.


73

PROBLEMA 5 Obtener las E.C. más simplificadas para F1 y F2.

PROBLEMA 6 Una empresa está probando un sistema de frenado y otro de servodirección en un prototipo. Dicho prototipo lleva un sensor de frenazo y otro de derrape. El sistema de frenado se activa en los siguientes casos: — El coche va a 1/3 de su potencia máxima y hay frenazo y derrape. — El coche va a 2/3 de su potencia máxima y hay frenazo. — El coche va a la máxima potencia y hay frenazo o derrape. El sistema de servodirección se desactiva en los siguientes casos: — El coche está parado. — El coche va a 1/3 de su potencia máxima y no derrapa. — El coche va a 2/3 de su potencia máxima y no frena. a) Dar las S.P.C. del sistema que activa los sistemas de frenado y servodirección. b) Implementar el sistema de frenado utilizando el menor número de puertas NAND. c)

Implementar el sistema de servodirección utilizando únicamente MUX de 4 a 1.

d) Implementar ambos sistemas utilizando un descodificador adecuado y puertas. PROBLEMA 7 Analiza la red de la figura y da la suma de productos más simplificada posible. ¿Es conjunto universal? Razona la respuesta.

74


PROBLEMA 8 Dado el sistema de la figura se pide: a) Suma de productos canónica de Z3 y Z2. b) Suma de productos simplificada de Z3 y Z2. c)

Reimplementa Z3 y Z2 utilizando el menor número de puertas NAND.

PROBLEMA 9 Diseñar detalladamente un descodificador de 3 a 8 utilizando únicamente descodificadores de menor tamaño. ¿Es el descodificador un conjunto universal? Razona la respuesta. PROBLEMA 10 Sea la F.C.: f (x3, x2, x1, x0) % Gm(0, 1, 2, 7, 8, 15) ! Gd(5, 11, 12). Escribe la suma de productos más simplificada posible. PROBLEMA 11 Sea el sistema de la figura donde el módulo M da salida 1 sólo si tiene un número par o cero de unos en la entrada. Escribe las ecuaciones del módulo M, de la salida F1 y de la salida F2.


75

PROBLEMA 12 Diseñar un sistema que transforme un número recibido a través de un teclado (del 0 al 9) en su equivalente braille levantando o bajando los 6 puntos de una pantalla táctil.

Diseña modularmente el sistema completo. Escribe la tabla de verdad del módulo traductor de decimal a braille. Implementa dicho módulo utilizando un descodificador y las puertas necesarias. PROBLEMA 13 Se pretende diseñar un termostato que encienda o apague la climatización de una sala. Dicho sistema tiene un regulador con 4 posiciones: {Apagado, 1/3, 2/3, Máximo}. Además tiene un sensor para la humedad que se activa si está por encima del 50% y otro sensor que se activa cuando la energía consumida supera los 4200 kWh. El sistema de climatización funciona cuando se cumple alguno de estos casos: – En posición de apagado, en el caso de que la humedad supere el 50%. – Si la energía consumida supera el límite pero se pone al máximo. – Si pone a 2/3 y no se supera el límite de energía. – Si se pone a 1/3. – Si la humedad supera el 50% y no se supera el límite de energía. – Si se pone al máximo y sin superar el límite de energía y la humedad no llega al 50%. Se pide: a) Hacer una codificación adecuada. b) Implementar el termostato utilizando multiplexores de 4 a 1 y puertas NOT si son necesarias. Escribe todos los cálculos necesarios. c)

Reimplementar utilizando ahora únicamente puertas NAND.

PROBLEMA 14 Diseñar una red iterativa que reciba n bits y funcione del siguiente modo: zi %

E

xi xi

si (xi.1 % 1) p (xi.2 % 0) en otro caso

Es decir: un bit de entrada se copiará si su bit «de la derecha» es 1 y «el de la derecha» de este último es 0 y se negará en cualquier otro caso. En otro caso el bit se cambia.

76


PROBLEMA 15 Dada la función de conmutación f (x2, x1, x0) % x2 x1 ! x2 x1 x0 ! x2 x1 x0 ! x2 x0 ! x2 x1, expresarla como suma de productos canónica y como suma de productos lo más simplificada posible. Implementar la función utilizando: a) Únicamente puertas NAND, utilizando el ménor número posible de ellas. b) Un MUX de 8 a 1. c)

Un descodificador y puertas.

d) Únicamente MUX de 4 a 1. PROBLEMA 16 Analizar la siguiente red de puertas NAND y expresar la función F(x, y) como suma de minitérminos y como suma de productos lo más simplificada posible. ¿Es conjunto universal? Razonar la respuesta.

PROBLEMA 17 Dado un elemento combinacional con la siguiente tabla de verdad. A

0 0

1 1

B

0 1

0 1

¿Existe algún valor de X para el cual dicho elemento sea conjunto universal? Justifica la respuesta. PROBLEMA 18 Analiza la red de puertas y da la expresión de conmutación de la salida tanto en su forma canónica como en suma de productos lo más simplificada posible.

3.1 Definición de sistema secuencial y concepto de estado 3.1.1 Sistema secuencial (Definición formal) Un sistema secuencial es aquel en el que la salida z en un instante dado ti es función F de la entrada x y el estado del sistema s en ese instante. Es necesario por tanto definir también el concepto de estado. Sin embargo no se define el estado actual, en el instante ti, el estado transcurrido un cierto tiempo desde el instante dado s(ti ! B), como una función G de la entrada x y el estado del sistema s en el instante ti.

E

z(ti) % F(x(ti), s(ti)) s(ti ! B) % G(x(ti), s(ti)) s(ti % 0) % DATO

3.1.2. Concepto de estado Los estados engloban los diferentes comportamientos que presenta el sistema de modo que se contemplen todos los posibles casos. Siempre definiremos el estado próximo al actual de modo que el estado inicial debe ser un DATO. Al ir entrando valores al sistema secuencial, éste irá modificando su estado, de modo que el estado en un instante determinado depende de todos los valores que han entrado hasta ese momento. Por esa razón, conociendo el estado actual (que es casi como conocer todos los valores posteriores) y la entrada actual podemos determinar la salida y también el comportamiento del sistema en el futuro inmediato, esto es el estado siguiente.

78


3.2 Clasificación de sistemas secuenciales 3.2.1 Sistemas síncronos y asíncronos Son sistemas síncronos aquellos en los que el estado cambia cada cierto tiempo constante llamado Periodo. Para marcar estos periodos de tiempo los sistemas síncronos están gobernados por una señar de reloj (CK) y en vez de escribir S(ti ! B) diriamos: S(ti ! 1). En los sistemas asíncronos no tenemos señal de reloj y por lo tanto los cambios de estado se producirán con los cambios de la entrada. Máquina de Mealy

E

z(ti) % F(x(ti), s(ti)) s(ti ! B) % G(x(ti), s(ti)) s(ti % 0) % DATO

Escribiremos las salidas en las aristas del diagrama de estados

Máquina de Moore

E

La salida SOLO depende

z(ti) % F(s(ti)) π∫ del estado, no de la entrada s(ti ! B) % G(x(ti), s(ti)) s(ti % 0) % DATO

Escribiremos las salidas en los estados del diagrama

3.3 Especificación binaria. Obtención de diagramas de estado 3.3.1 Reconocedores de secuencias Supongamos una secuencia de N estados. Estado inicial (Estado cero): Aún no hemos reconocido nada. Primer estado: Hemos reconocido el bit más antiguo de la secuencia.

Maq. Mealy

Segundo estado: Hemos reconocido los dos bits más antiguos; i.e: puesto que ya habíamos reconocido el más antiguo lo que hemos hecho ahora es reconocer el siguiente más antiguo. Tercer estado: Hemos reconocido los tres bits más antiguos. ...... Estado N-1: Hemos reconocido todos los bits de la secuencia excepto el último. Estado inicial (Estado cero): Aún no hemos reconocido nada. Primer estado: Hemos reconocido el bit más antiguo de la secuencia.

Maq. Moore

...... Estado N-1: Hemos reconocido todos los bits de la secuencia excepto el último. Estado N: Hemos reconocido TODOS los bits de la secuencia ú SALIDA % 1

Capítulo 3 Sistemas secuenciales

Ejemplo:

79

Sea el siguiente Sist. Sec.

E

z % 1 si x(t . 2) % a p x(t . 1) % b p x(t) % b z % 0 en otro caso

Lo que nos pide es, en definitiva, reconocer la secuencia a-b-b, donde la última b es el último bit que debe entrar. Los estados del sistema serían (haciéndolo como Mealy):

El siguiente paso es unir los estados con aristas marcadas con las entradas adecuadas para pasar del estado del que parten al que llegan; esto es: La arista que une dos estados está marcada con el nuevo bit que reconoce. – Si la máquina es de Mealy: en la arista también marcaremos la salida, que será 1 sólo en el caso de que partamos del estado N . 1 puesto que ya habremos reconocido todos los bits anteriores y es justo en este momento cuando reconocemos el que quedaba. – Si la máquina es de Moore entonces la salida será 0 en todos los estados menos en el último (estado N) en el que daremos salida 1 puesto que YA hemos reconocido la secuencia.

El último paso es completar el diagrama de estados con las aristas que faltan. De cada estado deben partir tantas aristas como posibles valores tiene el sistema para la entrada. La dificultad de los reconocedores está en dibujar correctamente las aristas. Si están mal la máquina realizará unas transiciones de estados incorrectas y por lo tanto dará salida 1 cuando debería dar salida 0!!! Versión Mealy:

80


Versión Moore:

3.3.2 Contadores Son máquinas de Moore que recorren los estados de manera correlativa. Su diagrama es: Obviamente este es el diagrama de estados de un contador ascendente, desde 0 hasta p . 1 (i.e., módulo p). Si fuera descendente las flechas irían en sentido contrario. También podemos convertirlo en un contador ascendente/descendente.

3.4 Implementación no canónica de reconocedores con biestables D Los biestables D síncronos tienen la característica de retrasar la marcha de la información un ciclo de reloj. De este modo, uniendo en cascada varios biestables podemos tener en un mismo instante la entrada actual (en ti) y el valor de la entrada en tantos instantes anteriores como biestables pongamos:


81

3.5 Implementación canónica Para la implementación de sistemas secuenciales a partir de su diagrama de estados necesitamos, como norma general, dos bloques combinacionales: uno para implementar la salida y otro para implementar el próximo estado. Si la máquina es de Moore la salida no dependerá de la entrada, mientras que las de Mealy sí. s(ti ! 1) % F(x(ti), s(ti)) G(s(ti)) ú Moore z(ti) % G(x(ti), s(ti)) ú Mealy s(ti % 0) % DATO

E

E

– El Próximo Estado (P.E.) está siempre a la ENTRADA del reg. de estado. – El Estado Actual (E.A.) está siempre a la SALIDA del reg. de estado. – Es imprescindible que el reg. de estado (los biestables que lo forman) se puedan inicializar de una manera ASINCRONA; para ello disponemos de la señal CLEAR.

3.6 Módulos secuenciales estándar 3.6.1 Registros Agrupación de biestables D que permiten cargar n bits en paralelo. Sólo carga si Clear % 0 y Load % 1.

82


3.6.2 Registros de desplazamiento Además de la carga en paralelo, permite desplazar el contenido del registro hacia la izquierda o derecha un bit con cada golpe de reloj. Podemos aprovechar esto para realizar multiplicaciones y divisiones por la base.

C0

C0

Acción

Z(t ! 1)

0 0 1 0

0 1 0 1

Nada @ A Carga

Z(t) Zn.2(t), ..., Z0(t), D I, Zn.2(t), ..., Z0(t) Zn.1(t), ..., Z0(t)

3.6.3 Banco de registros Un banco de registros es una agrupación de 2m registros, todos ellos de ancho n, sobre los que puedo leer o escribir. Tanto la lectura como la escritura se hace en paralelo, es decir lee/escribe los n bits en un único golpe de reloj. Para leer tenemos que dar: – ¿De qué registro vamos a leer? – Señal de Lectura. Para escribir tenemos que dar: – ¿En qué registro vamos a escribir? – ¿Qué vamos a escribir en ese registro? – Señal de Escritura. El dato que queramos escribir se coloca en las líneas de entrada. El dato que hayamos leído lo tendremos en las líneas de salida. Indicamos un registro poniendo su número, en binario, en las líneas de dirección.


83

3.6.4 Contadores – Clear % 0: Q(t ! Bt) % 0 r Resetear (asíncronamente) – Clear % 1 Load % 1: Q(t ! 1) % X(t) r Cargar Load % 0 Contar % 1: Q(t ! 1) % Q(t) ! 1 r Incrementar Contar % 0: Q(t ! 1) % Q(t) r No hace nada Implementación alternativa de sistemas secuenciales usando contadores Dado que el contador se puede comportar como un registro siempre podremos implementar un sistema secuencial usándolo para almacenar el estado siguiente; sin embargo para eso ya tenemos la implementación canónica. Si la mayoría de las transiciones entre estados es en el orden en que se modifica un contador, es decir: S0-S1-S2-S3-etc., o con muy pocas modificaciones en dicho orden tiene más sentido usar un contador que hacer la implementación canónica, puesto que los contadores implementan precisamente este tipo de diagramas de estado. Método: 1. Escribir la tabla de transición de estados. 2. Añadir a la derecha dos nuevas F.C.: LOAD y CONTAR. 3. Ir línea por línea de la tabla haciendo el siguiente cálculo: – Si P.E. % E.A. ! 1 entonces: LOAD % 0 y CONTAR % 1 – Si P.E. % E.A. entonces: LOAD % 0 y CONTAR % 0 – En cualquier otro caso LOAD % 1 y CONTAR % - 4. Habrá que generar la señal LOAD y la señal CONTAR. Para ello sabemos que ambas son señales combinacionales que dependen del E.A. (Q) y de las entradas del sistema secuencial. 5. Habrá que definir los valores de entrada para las ocasiones en que utilizamos la señal de LOAD para cambiar la transición «natural» del contador. Esto también lo haremos con un módulo combinacional que tiene por entradas el E.A. (Q) y las entradas del sistema secuencial. La implementación de la salida se hace igual que en la canónica y será diferente para máquinas de Mealy o de Moore.

84


3.7 Problemas resueltos PROBLEMA 1 Dar una especificación mediante diagrama de estados de un restador binario puro. AYUDA: Al restador le entran dos números representados en binario, empezando por el menos significativo y de modo que en cada instante de tiempo sólo entra un solo bit de cada uno de ellos. Solución: Denotando cada arco del diagrama de estados ab/c , donde a es el bit del primer operando, b el del segundo y c la salida del sistema, el diagrama final queda:

PROBLEMA 2 Obtener el diagrama y la tabla de transición de estados de un sistema secuencial con un bit de entrada y un bit de salida. La salida será igual a la entrada hasta que aparezca el segundo cero. A partir de ese instante la salida será la entrada negada. Ejemplo:

Entrada: Salida:

1 1 0 1 1 0

1 1

1 1

0 0

1 1 0 1 0 ... 0 0 1 0 1 ...

Solución: El diagrama consta de 3 estados que codifican la siguiente información: – S0: Aún no ha aparecido ningún cero. – S1: Ha aparecido el primer uno – S2: Ha aparecido el segundo uno, que según el enunciado no tiene por qué ser consecutivo.


85

Se trata de una máquina de Mealy, es decir, tanto el próximo estado como la salida en un instante dado dependen de la entrada en dicho instante. Por lo tanto la tabla de transición de estados y la tabla de salidas se pueden representar en una única tabla que, según el diagrama de estados, es: Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z0

0 0 0 0

0 0 1 1

0 1 0 1

0 1 1 X

1 0 0 X

0 0 1 X

1 1 1 1

0 0 1 1

0 1 0 1

0 0 1 X

0 1 0 X

1 1 0 X

PROBLEMA 3 Obtener el diagrama y la tabla de transición de estados de un sistema secuencial que cumpla la siguiente función de salida para una entrada x(t):

Ejemplo:

Entrada: Salida:

2

si

x(t . 2) % 1 p x(t . 1) % 0 p x(t) % 0

1

si

x(t . 2) % 1 p x(t . 1) % 1 p x(t) % 1

0

si se da cualquier otro caso

1 0

0 0

0 2

1 0

1 0

1 1

1 1

1 1

0 0

0 2

1 0

... ...

Solución: El diagrama consta de 4 estados que codifican la siguiente información: – S0: x(t . 2) % 0 (Estado inicial) – S1: x(t . 2) % 1 – S2: x(t . 2) % 1 p x(t . 1) % 1 – S3: x(t . 2) % 1 p x(t . 1) % 0

86


Al igual que en el problema anterior, la tabla de transición de estados y la tabla de salidas se pueden representar en una única tabla que, según el diagrama de estados, es: Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z1

Z0

0 0 0 0

0 0 1 1

0 1 0 1

0 1 0 1

0 0 0 0

0 0 1 0

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

0 1 0 1

1 1 1 1

0 0 0 0

1 0 0 1

PROBLEMA 4 Especificar mediante un diagrama de estados un sistema secuencial cuya salida z toma valor 1 sólo cuando x(t) % 1 p x(t . 1) % 0 p x(t . 2) % 1 p x(t . 3) % 1. Realizar una implementación canónica con puertas AND, OR y NOT. Solución: Siguiendo los pasos sugeridos en el apunte teórico el diagrama constaría de 4 estados que codifican la siguiente información: – S0: x(t . 3) % 0 (Estado inicial) – S1: x(t . 3) % 1 – S2: x(t . 3) % 1 p x(t . 2) % 1 – S3: x(t . 3) % 1 p x(t . 2) % 1 p x(t . 1) % 0


Simplificando obtenermos las EC del próximo estado (P.E.): D1 % Q1Q0 ! XQ1Q0 D0 % XQ1Q0 ! XQ1Q0 ! XQ1 . Q0 Y para la salida: Z % XQ1Q0 Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z0

0

0

0

0

0

0

0

0

1

0

0

0

0

1

0

1

1

0

0

1

1

0

0

0

1

0

0

0

1

0

1

0

1

1

0

0

1

1

0

1

0

0

1

1

1

0

1

1

87

88


PROBLEMA 5 Sea un sistema secuencial que da salida Z % 1 cuando se cumple que: X(t) % 0

X(t . 1) % 1

;

; X(t . 2) % 0

; X(t . 3) % 1

(es decir, reconoce la secuencia 1010, empezando por la izquierda). Se pide dibujar su diagrama de estados y hacer una implementación canónica con puertas AND, OR y NOT. Solución: El diagrama consta de 4 estados que codifican la siguiente información: – S0: x(t . 3) % 0 (Estado inicial) – S1: x(t . 3) % 1 – S2: x(t . 3) % 1 p x(t . 2) % 0 – S3: x(t . 3) % 1 p x(t . 2) % 0 p x(t . 1) % 1

Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z0

0

0

0

0

0

0

0

0

1

1

0

0

0

1

0

0

0

0

0

1

1

1

0

1

1

0

0

0

1

0

1

0

1

0

1

0

1

1

0

1

1

0

1

1

1

1

0

1


89

Simplificando tenemos: D1 % XQ1 ! XQ0

,

D0 % XQ1 ! XQ0

y

Z % Q1Q0

PROBLEMA 6 Sea un sistema secuencial que da salida % 1 si ha recibido un número par de unos y la entrada actual y la anterior son ambas igual a cero. a) ¿Se puede diseñar como máquina de Mealy, de Moore, o ambas? Justifica la respuesta. b) Dibuja el diagrama de estados. NOTA: No haber recibido ningún uno se considerará distinto a haber recibido un número par de unos. c)

Diseñar un sistema combinacional de n entradas que da salida % 1 sólo cuando recibe un número impar de unos por ellas y las dos últimas (xn.1 y xn.2) son iguales a cero. Dar las tablas de verdad que consideres necesarias e implementar con los módulos o puertas que prefieras.

Solución: a) Puesto que según el enunciado la salida depende de la entrada actual entonces es necesario diseñarlo como máquina de Mealy. b) El diagrama consta de 4 estados que codifican la siguiente información: – S0: Estado inicial. No se ha recibido ningun uno. – S1: Se ha recibido un número impar de unos, no tiene por qué ser consecutivos. – S2: Se ha recibido un número par de unos, no tiene por qué ser consecutivos.

90


– S3: Se ha recibido un número par de unos y el último bit recibido es un cero.

c)

Para resolverlo hay que construir una red iterativa. El bit que se transmite de una celda a otra codifica si en las celdas de índice menor se ha recibido un número impar de unos en total. C

Significado

0

Ninguno o número par de unos

1

Número impar de unos

Las penúltima celda (con índice n . 1) además debe transmitir a la última un bit P % X(n . 1) para que la última celda (con índice n) decida si la salida es cero o uno.

La celda genérica tendrá la siguiente tabla de verdad: X(K)

C(K)

C(K ! 1)

0

0

0

0

1

1

1

0

1

1

1

0

C(k ! 1) es un puerta XOR. Para dar salida 1 se debe cumplir: (X(n) % 0) p (P % 0) p (C(n) % 1). Esta condición se puede implementar con una puerta AND con dos entradas negadas.


91

Aunque este último apartado pertenece a circuitos combinacionales ha sido incluido en este ejercicio para mostrar cómo un autómata finito y una red iterativa sencilla guardan muchos puntos en común. La información que una celda transmite a su izquierda resume la información recibida por el sistema en las celdas de su derecha. Esta es precisamente la definición de estado, con la diferencia fundamental de que el estado resume la información recibida anteriormente, es decir en el tiempo, no en el espacio. PROBLEMA 7 Sea un sistema secuencial S1 que da salida Z1 % 1 si los cuatro últimos bits que ha recibido son 1001. Sea un sistema secuencial S2 que da salida Z2 % 0 si los tres últimos bits que ha recibido son 010. Sea un sistema secuencial S3 que genera la secuencia 1 0 0 mientras su entrada valga 1. a) Dibujar el diagrama de estados de cada uno de los sistemas. b) Dar la tabla de transición de estados y de salida de S2. c)

Diseñar el sistema S1 y S2 usando biestables D y puertas lógicas.

NOTA: No es necesario hacer una implementación canónica. Solución: a) Siguiendo las indicaciones del apunte teórico se puede obtener fácilmente el diagrama de estados de los sistemas S1 y S2. Para el sistema S1 se tienen 4 estados que codificarían la siguiente información: – – – –

S0: x(t . 3) % 0 (Estado inicial) S1: x(t . 3) % 1 S2: x(t . 3) % 1 p x(t . 2) % 0 S3: x(t . 3) % 1 p x(t . 2) % 0 p x(t . 1) % 0

Para el sistema S2 se tendría los siguientes 3 estados: – S0: x(t . 2) % 1 (Estado inicial) – S1: x(t . 2) % 0 – S2: x(t . 2) % 0 p x(t . 1) % 1

92


Para el sistema S3 es un generador. Su diagrama de estados es el de un contador, en este caso módulo 3.

b) Las tablas de transición y salida de S2 se pueden juntar en una única tabla, pues S2 es una máquina de Mealy por lo que tanto el próximo estado como la salida en un instante dado dependen del estado actual y de la entrada en dicho instante. La tabla será entonces: Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z0

0 0 0 0

0 0 1 1

0 1 0 1

0 0 0 X

1 1 1 X

1 0 0 X

1 1 1 1

0 0 1 1

0 1 0 1

0 1 0 X

0 0 0 X

1 1 1 X


c)

93

Utilizando biestables D se pueden implementar los sistemas S1 y S2 sin conocer el diagrama de estados, simplemente almacenando las 3 últimas entradas para el caso de S1 y las dos últimas para S2. El resultado es:

PROBLEMA 8 Sea un reconocedor de dígitos codificados en BCD tal que los bits llegan en serie (es decir, uno tras otro) comenzando por el menos significativo. a) Especificarlo mediante un diagrama de estados, diciendo si se hace como máquina de Moore o de Mealy. b) Diseñar el sistema, usando biestables D y puertas de un único tipo sin recurrir al diagrama de estado. Solución: El BCD es un código de 4 bits. Por tanto, hasta que no se reciben 4 bits seguidos no se considera un nuevo número. Puesto que los bits llegan al sistema comenzando por el menos significativo se pueden dar dos casos distintos: – Si el primer bit que llega es un 0 o un 1 y después un 0: Entonces para que la salida sea 1 debe llegar a continuación: o bien un 0 y luego un 0 o 1 o bien 1 y luego 0. – Si el primer bit que llega es un 0 o un 1 y después un 1. Entonces para que la salida sea 1 debe llegar a continuación un 0 o un 1 y luego un 0.

94


En resumen, el diagrama de estados resultante es:

Respecto a la implementación, dado que los biestables D añaden un retardo de un ciclo, se puede diseñar un sistema que reconozca cuándo los 4 últimos bits recibidos por el sistema pertenecen al código BCD, teniendo en cuenta las siguientes consideraciones: Puesto que la secuencia comienza por el menos significativo el número en BCD N formado por la sucesión de 4 bits es (X(t)X(t . 1)X(t . 2)X(t . 3))BCD. La Suma de Productos Canónica que determina si N es BCD es: f (X(t), X(t . 1), X(t . 2), X(t . 3)) % Gm(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

La Suma de Productos más simplificada es f (X(t), X(t . 1), X(t . 2), X(t . 3)) % X(t) ! X(t . 2)X(t . 1) Puesto que la salida depende sólo de los últimos bits almacenados, se puede implementar con una serie de biestables D del siguiente modo:


95

Como se indicó al comienzo del problema, hasta que no se reciben 4 bits seguidos no se considera un nuevo número. Sin embargo, la salida del diseño propuesto tomaría valor 1 tras una secuencia de 4 ceros, en el momento en el que recibiera el siguiente bit, tanto si es cero como si es uno. O sea que la salida toma valor 1 pero el nuevo número aún no se ha formado, de hecho sólo ha recibido el bit menos significativo. Para evitar esto debemos añadir al sistema generado un contador módulo 4 de modo que cuando llegue al final de la cuenta capacite la salida. Llamando S al sistema diseñado arriba, el sistema completo sería:

Como última nota, la segunda puerta NAND es necesaria para construir un negador que anule el efecto de la primera NAND, ya que según el enunciado sólo permite el uso de un tipo de puertas y S está implementado con NANDs. PROBLEMA 9 Dado el siguiente diagrama de estados: Dibujar de forma esquemática su implementación canónica. Implementar dicho sistema usando un contador y los módulos combinacionales necesarios. Implementar dicho sistema usando biestables D y multiplexores 4 a 1.

96


Solución: Las tablas de transición de estados y de salida se pueden agrupar en una sola pues es una máquina de Mealy. Por tanto el esquema de su implementación canónica es:

Para implementar con un contador con carga en paralelo hay que analizar el diagrama de estados; i.e., obtener su especificación en forma de tabla de transición de estados y de salidas. En la tabla se añade una columna L para indicar en qué transiciones se debe cargar la entrada del contador. Se supone además que C % 1 de modo que cuando L % 0 el contador se incrementa. Entrada

E.A.

P.E.

Salida

Contador

X

Q1

Q0

D1

D0

Z

L

E1

E0

0 0 0 0

0 0 1 1

0 1 0 1

0 1 1 0

1 0 1 0

1 1 0 0

0 0 0 0

X X X X

X X X X

1 1 1 1

0 0 1 1

0 1 0 1

1 1 1 1

0 0 0 0

0 1 0 1

1 X 1 1

1 1 1 1

0 0 0 0


La implementación basada en contador es:

La implementación canónica con MUX de 4 a 1 es:

97

98


PROBLEMA 10 Sea un reconocedor de secuencias que da salida % 1 en alguno de estos dos casos: x(t . 2) % 1 p x(t . 1) % 0 p x(t) % 0 x(t . 2) % 0 p x(t . 1) % 1 p x(t) % 1 a) Dibujar el diagrama de estados. b) Realizar su implementación canónica. Solución: a) Este problema, que en apariencia es similar a otros reconocedores de dos secuencias, y que a priori no parece entrañar una excesiva dificultad, resulta complejo porque las secuencias que se desea reconocer se pueden solapar. Es decir, si el bit que recibe el sistema en el instante actual es un 0 puede darse el caso de que dicho cero, pasados dos flancos de reloj, sirva para reconocer la segunda secuencia del enunciado. De este modo son necesarios 5 estados que codifican la siguiente información: – S0: Estado inicial de la máquina, aún no ha recibido ningún bit. – S1: x(t . 2) % 0 – S2: x(t . 2) % 0 p x(t . 1) % 1 – S3: x(t . 2) % 1 – S4: x(t . 2) % 1 p x(t . 1) % 0 El diagrama de estados y las tablas de transición de estados y de salida a la que da lugar son:


Entrada

Est. actual

Próximo est.

99

Salida

X

Q2

Q1

Q0

D2

D1

D0

Z

0 0 0 0

0 0 0 0

0 0 1 1

0 1 0 1

0 0 1 1

0 0 0 0

1 1 0 0

0 0 0 0

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

1 X X X

0 X X X

1 X X X

1 X X X

1 1 1 1

0 0 0 0

0 0 1 1

0 1 0 1

0 0 0 0

1 1 1 1

1 0 1 1

0 0 1 0

1 1 1 1

1 1 1 1

0 0 1 1

0 1 0 1

0 X X X

1 X X X

0 X X X

0 X X X

b) Para la implementación canónica utilizamos un decodificador de 4 a 16 y puertas OR.

100


PROBLEMA 11 Sea un reconocedor de secuencias cuya salida % 1 cuando la entrada actual es 1, antes de ella, en algún momento, ha habido un número cualquiera de ceros (incluso ninguno) y antes de dicha secuencia hubo un uno. Por ejemplo: Entrada:

0

0

1

1

1

0

1

0

0

0

0

1

1

1

0

1...

Salida:

0

0

0

0

0

0

1

0

0

0

0

1

1

1

0

1...

a) Dibujar el diagrama de estados. b) Realizar su implementación canónica. Solución: a) El diagrama de estados más sencillo es el siguiente: – S0: Ha habido un número cualquiera de ceros o ninguno (estado inicial). – S1: Ha aparecido el primer uno.

b) La tabla de transición de estados y de salidas es por tanto: X

Q

D

Z

0 0 0 0

0 1 0 1

0 1 1 1

0 0 0 1

Es fácil ver que la EC del próximo estado D % X ! Q y que la EC de la salida Z % X . Q luego la implementación canónica es:


101

PROBLEMA 12 Implementar el siguiente diagrama de estados en el que la salida % estado actual. a) Mediante una implementación canónica usando un descodificador y puertas. b) Utilizando un contador módulo 8 con carga en paralelo y puertas NAND.

Solución: La siguiente tabla representa la entrada (X), el estado actual (Q2, Q1, Q0) y el próximo estado (D2, D1, D0). La salida, según el enunciado es igual al estado actual. Además para resolver el apartado b) se amplía con las entradas del contador: L % Load, C % Incrementar cuenta, E2E1E0 % Entradas en paralelo. Entrada

Est. actual

Próximo est.

Contador

X

Q2

Q1

Q0

D2

D1

D0

L

C

E2

E1

E0

0 0 0 0

0 0 0 0

0 0 1 1

0 1 0 1

0 0 0 1

0 1 1 0

1 0 1 0

0 0 0 0

1 1 1 1

X X X X

X X X X

X X X X

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

0 X X X

0 X X X

0 X X X

1 X X X

X X X X

0 X X X

0 X X X

0 X X X

1 1 1 1

0 0 0 0

0 0 1 1

0 1 0 1

0 0 0 0

1 1 1 0

0 1 0 1

1 1 0 1

X X 0 X

0 0 X 0

1 1 X 0

0 1 X 1

1 1 1 1

1 1 1 1

0 0 1 1

0 1 0 1

1 X X X

0 X X X

0 X X X

0 X X X

0 X X X

X X X X

X X X X

X X X X

102


a) La implementación canónica es la siguiente:

b) Es necesario calcular la suma de productos simplificada para las señales L, C, E2, E1 y E0.


103

PROBLEMA 13 Dado el sistema secuencial implementado en la figura, se pide responder razonadamente a las siguientes cuestiones: a) Dar el diagrama de estados. b) Dar la E.C. más simplificada posible de la señal LOAD y CONTAR que usaríamos si quisiésemos hacer una implementación con contador. ¿Sería conveniente usar un contador para implementar el sistema?

104


c)

Suponer que hay un biestable más (D3), a cuya entrada conectamos X y cuya salida se une con la línea de dirección E2 de la ROM. ¿Cuántos estados tendrá el sistema?, ¿es una máquina de Mealy o de Moore?

Solución: La tabla de verdad es: Entrada

E.A.

P.E.

Salida

Contador

X

D1

D0

Q1

Q0

Z

L

C

0 0 0 0

0 0 1 1

0 1 0 1

0 1 1 0

1 0 0 0

0 0 1 1

0 0 0 0

1 1 0 1

1 1 1 1

0 0 1 1

0 1 0 1

0 1 1 1

0 0 1 1

0 1 1 0

0 0 0 0

0 1 1 0


105

Aunque la EC de la señal Contar (C) es algo compleja, L % 0 por lo que no hay que generar las señales de entrada la contador. En conclusión la alternativa de una implementación con es aceptable.

Si se añade el biestable D3 como indica el enunciado entonces habría 3 bits para codificar el estado y por tanto 8 estados. El bit más significativo del PE % X. Ahora Z(t) no depende de X(t), sólo del Estado Actual EA(t) y por tanto se convertiría en una máquina de Moore. PROBLEMA 14 Obtener la tabla de transición de estados y de salida del siguiente sistema secuencial y realizar una implementación canónica usando sólo multiplexores de 4 a 1, negadores y biestables.

Solución: Lo más importante a la hora de analizar un sistema secuencial es escribir correctamente la cabecera de la tabla de verdad de transición de estados y de salidas. Mirando la red de puertas NOR parece, salvo posteriores simplificaciones, que Z(t) depende de X(t). Por tanto se trataría de una máquina de Mealy y podemos juntar ambas tablas en una sola. Por último, puesto que hay dos biestables el estado se codifica con dos bits.

106


En definitiva, la cabecera sería: Entrada X

Estado Actual Q1

Próximo Estado

Q0

D1

D0

Salida Z

Para analizar el sistema combinacional que da lugar a la salida y al próximo estado conviene en primer lugar trabajar sobre el circuito equivalente de la figura, donde se han transformado las puertas NOR de los niveles impares por sus equivalentes AND con entradas negadas. Además se han eliminado los biestables para mayor claridad. Aplicando la ley de Moore para la suma, x ! y % x . y, se puede sustituir algunas puertas NOR por su equivalente AND con entradas negadas de modo que en un mismo cable se enfrenten dos negadores y por tanto se anulen. De este modo la red resultante queda:

Calculando los puntos Ti obtenemos: T1 % X . Q1 T2 % Q1 . Q0 T3 % X ! T1 % X ! X . Q1 % X ! Q1 T4 % T1 ! T2 % X . Q1 ! Q1 . Q0 T5 % Q0 ! X Z % T3 . T4 % (X ! Q1)X . Q1 % X . Q1 D1 % X . T4 % X(X . Q1 ! Q1 . Q0) % X . Q1(1 ! Q0) % X . Q1 D0 % T4 . T5 % (X . Q1 ! Q1 . Q0)(Q0 ! X) % X . Q1 . Q0 ! X . Q1 . Q0


107

La tabla de verdad queda: Entrada

E.A.

P.E.

Salida

X

Q1

Q0

D1

D0

Z

0 0 0 0

0 0 1 1

0 1 0 1

1 1 0 0

0 1 0 0

1 1 0 0

1 1 1 1

0 0 1 1

0 1 0 1

0 0 0 0

1 0 0 0

0 0 0 0

Para la implementación con MUX de 4 a 1 se eligen las variables de control X y Q1.

PROBLEMA 15 Diseñar una pila de 4 bits, síncrona y con señal de Clear. La pila se controla con una señal como se puede apreciar en la figura. En una pila el primer bit que se recibe es el último que se genera, el segundo bit que se recibe es el penúltimo que se genera y así sucesivamente hasta el último bit que se recibe, que es el primero en generarse.

Solución: Se trata de modificar el diseño de un registro de desplazamiento para que se ajuste a la especificación.

108


Suponemos que cuando la pila está «vacía» contiene 4 ceros. Por último, el diseño no incluye la señal de CLEAR para resultar más claro. Todos los biestables deben recibir dicha señal, que generalmente es asíncrona y se activa en baja. La señal de reloj (CK), como es habitual, se conecta en la marca triangular de los biestables. Todos deben funcionar con la misma CK. El diseño finalmente es:

PROBLEMA 16 Diseñar un registro de 4 bits con entrada y salida en paralelo y las siguientes funciones: C1

C0

Q(t ! 1)

0 0 1 1

0 1 0 1

Q(t) 2 # Q(t) 4 # Q(t) E(t)

AYUDA: Para multiplicar por dos un número binario desplazamos hacia la izquierda todos los elementos una posición, introduciendo un cero por la derecha. Para multiplicar por cuatro hay que desplazar dos posiciones e introducir dos ceros.


109

Solución:

PROBLEMA 17 Diseñar el control de un brazo robot que ponga tapones a presión en botellas. Las botellas se desplazan sobre una cinta, en cajas 3 # 3. El robot realiza el siguiente trayecto sobre una caja:

n % El brazo se mueve una posición hacia abajo p % El brazo se mueve una posición a la izquierda m % El brazo se mueve una posición hacia arriba ú % El brazo se mueve dos posiciones a la derecha y la cinta avanza hasta la próxima caja de botellas. Para ello utilizaremos un contador más las puertas y/o módulos combinacionales que creamos convenientes. AYUDA: Considerar los cuatro movimientos como la salida del sistema secuencial que implementamos con el contador y que serán entradas del sistema del brazo y la cinta (y de los cuales NO nos piden nada).

110


Solución: Necesitamos un contador de 1 a 9. Para construirlo utilizaremos un contador módulo 16 modificándolo para que comience en 1 y acabe en 9. Por otro lado mi sistema produce 4 salidas diferentes {m, n, p, ú}, por lo que necesitamos 2 bits para codificarlas y un sistema combinacional que las implemente. Salida

Estado en el que se produce

m n p ú

4, 5 1, 2, 7, 8 3, 6 9

Codificación 0 0 1 1

0 1 0 1

Utilizando una puerta AND para truncar la cuenta y un descodificador 4 a 16 y puertas OR para generar la salida Z % [Z1, Z0], que codifica la información que recibe tanto el brazo como la cinta, el diseño quedaría como muestra la figura.

PROBLEMA 18 Diseñar un sistema secuencial que recibe bits en serie con cada flanco de reloj y da salida % 1 cuando el número binario formado por los 4 últimos bits que han entrado, siendo x(t) el bit más significativo, es múltiplo del 3, del 5 o del 7. El sistema tiene 2 entradas adicionales (S1 y S0) para seleccionar de cuál debe ser múltiplo. Usar un descodificador de 4 entradas y un MUX de 4 a 1, puertas y los biestables D que consideres necesarios. AYUDA: No es necesario hacer ningún diagrama de estados.


111

Solución: El sistema se compone de los siguientes módulos. Un registro con carga en serie y salida en paralelo de 4 bits y un subsistema combinacional que recibe los 4 últimos bits recibidos y una entrada de dos bits que codifica el divisor que queremos probar del siguiente modo: Múltiplo:

0 0

0 1

1 0

Divisor:

3

5

7

Para el registro se utilizan biestables D y para el subsistema combinacional se utiliza el descodificador y el MUX de 4 a 1. El descodificador recibe los 4 últimos bits que forman un número binario entre 0 y 15. Una puerta OR agrupa todas las líneas de salida del descodificador múltiplo de 3. Igualmente otras dos puertas OR agrupan las líneas múltiplo de 5 y de 7. Finalmente cada una de estas puertas OR se conecta al MUX de 4 a 1, en la entrada de datos adecuada según la codificación de los divisores. El resultado es:

112


PROBLEMA 19 Diseñar un generador de secuencias con el siguiente funcionamiento: Mientras la entrada G sea igual a 1 se genera cíclicamente la secuencia de 4 bits definida por el usuario, {u3, u2, u1, u0}; si G es igual a 0 la secuencia genera continuamente el bit en el que se quedó. Dar una descripción modular del generador y especificar mediante un diagrama de estados los elementos secuenciales que aparezcan.

Solución: El sistema se compone de un contador módulo 4 que se avanza cuando la señal G % 1 y se detiene en un estado cuando G % 0. La salida del contador coincide con el estado en el que se encuentra. Dicho estado actúa como señales de selección sobre un multiplexor al que se conectan las entradas de usuario. Se ha supuesto que el primer bit en generarse es u3. El resultado es:


113

PROBLEMA 20 La torre de control de un aeropuerto rastrea una circunferencia de radio 60 millas cada segundo. Cuando detecta un avión por debajo de los 4000 pies le envía un código por radio indicándole el sector en el que se encuentra (todos los bits se envían al mismo tiempo, no uno tras otro).

El sistema de aterrizaje del avión dispone de un dispositivo que detecta cuándo se pasa de un sector a otro y genera mensajes, según sea la transición, siguiendo la tabla. Mensaje

Transición de sectores

Acercamiento

Del 0 al 1 y del 1 al 2

Alejamiento

Del 3 al 1 y al 2, del 2 al 1 y del 1 al 0

Aproximación final

Del 2 al 3

Aproximación de emergencia

Del 1 al 3

Aproximación negada

Del 0 al 3

Salir de vía aérea

Del 3 al 2

Diseñar el sistema que genera la señal de cambio de sector y los mensajes en función de los códigos que va recibiendo de la torre de control usando biestables D y elementos combinacionales. El mensaje debe permanecer hasta que se produzca uno nuevo. Explica claramente la codificación realizada. NOTA: No es necesario hacer diagrama de estados.

114


Solución: En primer lugar se codifican los diferentes mensajes en binario. Necesitamos 3 bits. Una posible codificación es: 000 %

Acercamiento

001 %

Alejamiento

010 %

Aprox. final

011 %

Aprox. de emergencia

100 %

Aprox. negada

101 %

Salir de la vía aérea

Respecto a los sectores, al haber 4 serían necesarios dos bits. La codificación es directamente en binario. El sistema debe almacenar continuamente el penúltimo mensaje recibido para compararlo con el último y detectar un cambio (Señal C) así como el mensaje que se debe generar en dicho caso. Para almacenar el sector en el que se encuentra se deben utilizar dos biestables D. Finalmente, para que el último mensaje esté activo hasta que se genere uno nuevo, es decir, hasta que haya una nueva señal C, se debe almacenar también. Puesto que consta de 3 bits necesitaremos 3 biestables. Un descodificador activa una de las 6 luces del cuadro de controles del avión según el código que recibe. El diseño final es el siguiente:


115

El sistema combinacional utilizado viene especificado por la siguiente tabla de verdad: Sector antes C1(T . 1) C0(T . 1)

Sector ahora

Mensaje

Cambio

C1(T)

C0(T)

M2

M1

M0

C

0 0 0 0

0 0 0 0

0 0 1 1

0 1 0 1

X 0 X 1

X 0 X 0

X 0 X 0

0 1 X 1

0 0 0 0

1 1 1 1

0 0 1 1

0 1 0 1

0 X 0 0

0 X 0 1

1 X 0 1

1 0 1 1

1 1 1 1

0 0 0 0

0 0 1 1

0 1 0 1

X 0 X 0

X 0 X 1

X 1 X 0

X 1 0 1

1 1 1 1

1 1 1 1

0 0 1 1

0 1 0 1

0 0 1 X

0 0 0 X

1 1 1 X

1 1 1 0

3.8 Problemas propuestos PROBLEMA 1 Queremos diseñar un juego de azar compuesto por 2 botones (J1 y J0) y una pantalla que se ilumina cuando el jugador gana. Tiene el aspecto externo de la figura y funciona del siguiente modo: Apretando J1 ponemos en marcha un contador que genera la secuencia {2, 3, 6, 7} de forma cíclica y tiene una frecuencia de reloj de 100 Hz. Apretando J0 ponemos en marcha otro contador. Este genera la secuencia {1, 3, 7, 2, 5, 6}, también de forma cíclica, y su frecuencia es de 250 Hz.

Si al soltar los dos botones coinciden los números de sendos contadores se iluminará la pantalla y el jugador habrá ganado. Hacer un diseño modular del aparato. Dibujar el diagrama de estados de ambos contadores razonando si se trata de máquinas de Mealy o de Moore.

116


Implementar el Sistema Combinacional que provoca la salida. ¡¡No se recomienda hacer una tabla de verdad!! PROBLEMA 2 Dado el siguiente sistema secuencial: – – – –

Si X(t . 2) % b ⵧ X(t . 1) % b ⵧ X(t) % b, salida % 1, Si X(t . 2) % b ⵧ X(t . 1) % b ⵧ X(t) % a, salida % 2, Si X(t . 2) % b ⵧ X(t . 1) % a ⵧ X(t) % a, salida % 3, En cualquier otro caso, salida % 0.

Se pide: Dibujar el diagrama de estados de la máquina. Escribir la tabla de transición de estados y la tabla de verdad. Realizar una implementación canónica usando descodificadores y puertas. PROBLEMA 3 Diseñar un sistema secuencial cuya salida sea: – Igual a la entrada bit a bit hasta el instante en que hayan entrado dos unos consecutivos. – A partir de ese momento la salida será el negado de la entrada hasta que el sistema reciba dos ceros consecutivos. — Desde ese momento la salida volverá a ser igual a la entrada. Ejemplo:

Entrada:

0

1

0

1

1

0

1

0

1

0

0

1

0

1

1

1...

Salida:

0

1

0

1

1

1

0

1

0

1

1

1

0

1

1

0...

Se pide: a) Dibujar el diagrama de estados y la tabla de transición del sistema. b) Realizar una implementación canónica usando biestables D, descodificadores y puertas R. c)

Dar la E.C. más simplificada posible de la señal LOAD que usaríamos si quisiésemos hacer una implementación con contador. ¿Merece la pena usar un contador para implementar el sistema? (Razona la respuesta.)

NOTA: Se valorará más un diagrama de estados minimizado. PROBLEMA 4 Diseñar un registro de 3 bits con capacidad de desplazamiento a la izquierda, y carga en paralelo usando multiplexores y biestables. El registro tendrá una entrada de control de 1 bit que indicará la función a realizar. Además tendrá entrada para la carga en serie y paralelo. PROBLEMA 5 Sea un sistema secuencial S1 que da salida Z1 % 1 si los cuatro últimos bits que han entrado son 1001.


117

Sea un sistema secuencial S2 que da salida Z2 % 0 si los tres últimos bits que han entrado son 010. Sea un sistema secuencial S3 que genera la secuencia 1 0 0 mientras su entrada esté a 1. a) Dibujar el diagrama de estados de cada uno de los sistemas secuenciales b) Dar la tabla de transición de estados y de salida de S2. c)

Diseñar el sistema S1 y S2 usando biestables D y las puertas lógicas que necesites.

PROBLEMA 6 Implementar el diagrama de estados dado utilizando un contador y los módulos combinacionales que sean necesarios. La salida es igual al estado actual.

PROBLEMA 7 Diseñar un reconocedor de secuencias tal que la salida es: Z1 % 1 si [x(t . 3), x(t . 2), x(t . 1), x(t)] es un número en notación C2 con valor absoluto mayor o igual que 3. Z0 % 1 si [x(t . 3), x(t . 2), x(t . 1), x(t)] es un número que representa un código BCD. Z1 % Z0 % 0 en cualquier otro caso. PROBLEMA 8 Diseñar un sistema secuencial que admita bits en serie y da salida % 1 sólo cuando el número binario formado por los cuatro últimos bits recibidos, {x(t), x(t . 1), x(t . 2), x(t . 3)}, siendo x(t) el bit más significativo, sea igual a 0, 4, 8, 10, 13 o 15. Utilizar únicamente biestables D, puertas NOT (si son necesarias) y MUXs de 4 a 1. PROBLEMA 9 Especificar mediante un diagrama de estados un sistema secuencial que admita de salida Z % 1 sólo cuando x(t) % 1 p x(t . 1) % 0 p x(t . 2) % 1 p x(t . 3) % 1.

118


PROBLEMA 10 Diseñar un banco de 32 registros de 8 bits tal que se pueda escribir en uno de ellos y leer de dos distintos en el mismo ciclo de reloj. Señales: – – – – – – – –

SE: Selección de escritura. SL1: Selección de Lectura del primer registro. SL2: Selección de Lectura del segundo registro. D in: Datos de entrada. Dout 1: Dato de salida del primer registro. Dout 2: Dato de salida del segundo registro. E: Enable (capacitación). Escribir: Señal de escritura.

Una vez que se han estudiado y comprendido los distintos módulos digitales y secuenciales, el lector ya debe tener asimilados los conceptos fundamentales de sistemas digitales y su diseño a través de una relación entre las entradas y las salidas del sistema. Concibiendo el diseño de un procesador, o incluso un computador completo, como un conjunto de sistemas digitales conectados entre sí, el paso previo al diseño de un computador sencillo es el diseño algorítmico de sistemas digitales.

4.1 Esquema general de un sistema diseñado algorítmicamente A la hora de realizar el diseño algorítmico de un sistema digital debemos introducir dos conceptos: Ruta de datos. Unidad de control. La ruta de datos o procesador del sistema se encarga de procesar la información de entrada y proporcionar la información de salida. Para generar esta información de salida debe seguir los pasos que la unidad de control le indique. Para ello la unidad de control generará las señales necesarias para que los datos se procesen correctamente y se las enviará a la ruta de datos. El diseño algorítmico de un sistema consiste en, partiendo de una especificación del sistema en forma de algoritmo o pseudocódigo, obtener la ruta de datos y la unidad de control que realizan la funcionalidad descrita por el algoritmo. El esquema general de un sistema diseñado algorítmicamente aparece en la figura de la página siguiente.

120


La ruta de datos estará compuesta por un conjunto de módulos digitales combinacionales y secuenciales que procesan la información. Estos módulos serán los utilizados y diseñados en los capítulos anteriores:

Multiplexores y demultiplexores. Codificadores y decodificadores. Puertas lógicas y sistemas combinacionales. Comparadores. Registros de carga y/o desplazamiento. Contadores. Sumadores. Etcétera. Asociados a todos ellos existen generalmente un conjunto de señales que los controlan. Estas señales las genera la unidad de control en cada uno de los pasos que debe seguir la ruta de datos. El sistema seguirá una serie de pasos para cumplir el algoritmo que serán marcados por esta unidad de control, que será por tanto un sistema secuencial en el que cada estado corresponde con uno de los pasos necesarios para que se resuelva el algoritmo y en el que el proceso de diseño será el típico asociado a un sistema secuencial. De igual forma la unidad de control proporcionará a la ruta de datos las señales de carga, desplazamiento, selección, etc., que correspondan en cada estado.

Capítulo 4 Introducción al diseño algorítmico de sistemas

4.2 Proceso de diseño

4.3 Problemas resueltos PROBLEMA 1 Dados el siguiente algoritmo y la siguiente ruta de datos (U.P.) que lo implementa: A p dato 1 B p dato 2 If (A % B) then A p (2*A) ! (B/2) Else A%A

121

122


Se pide dibujar el diagrama de estados de la U.C. y dar la tabla de verdad con los valores que toman las señales de control en cada estado. La U.C. genera, además de las señales indicadas, una señal de FIN. AYUDA: Funcionamiento de los registros. C1 0 0 1 1

C0 0 1 0 1

Función Cargar A @ –Nada–

Solución: A la hora de saber cuántos estados tiene la unidad de control, lo primero que tenemos que identificar son los registros de datos ya que son ellos los que van a marcar el número de ciclos del proceso. Cada vez que un dato llega a un registro se produce un almacenamiento con la llegada del reloj, o lo que es lo mismo hasta que no haya un ciclo nuevo no puede atravesar el registro. Hay que decidir cómo se implementa la unidad de control, lo habitual es hacerlo como una máquina de Moore en el que cada estado tenga sus correspondientes valores de salida y en ocasiones se pueden establecer estados en los que realmente sólo se hagan cálculos combinacionales y obtención de condiciones. Debemos por tanto establecer el número de estados y para ello construimos primero el diagrama de flujo el algoritmo. De él prácticamente obtenemos el diagrama de estados. En todos los problemas supondremos que existe una señal de inicio que llevaría al sistema al estado inicial, aunque no la representemos en todos los diagramas de estado para obtener diagramas más claros y didácticos.


123

También es conveniente identificar los estados y dar una breve explicación de la actuación de la ruta de datos. En este caso los estados son 4 según la siguiente tabla. Estado 0 (S0)

Carga de datos

Estado 1 (S1)

Comparación

Estado 2 (S2)

Cálculo de la operación

Estado 3 (S3)

Fin

El esquema de conexión entre la ruta de datos y la unidad de control será:

124


Y el diagrama de estados con la señal de inicio explícita:

Cada vez que se quiera comenzar se debe pasar la señal de borrado (Clear) de los registros a 0 y luego a 1 para regresar al estado 0. La correspondencia de los estados con las salidas será: Estado

MUX

C1A

C0A

C1B

COB

Fin

0

1

0

0

0

0

0

1

X

1

1

1

1

0

2

0

1

0

0

1

0

3

0

0

0

X

X

1

Una opción interesante sería hacer la que la señal de Clear coincida con la de Inicio, de esta forma podríamos reducir el tamaño de las tablas de transición de estados ya que, al ser asíncrona no aparecería explícitamente en el diagrama. PROBLEMA 2 Dado el siguiente algoritmo: Cont p 8; A p dato; Repeat B p Cont * 2; Decrementar Cont; Until B n A


125

Se pide: Diseñar la unidad de proceso usando un sumador/restador y multiplexores como únicos elementos combinacionales (ver gráfico). Suponer números de 8 bits en complemento a 2. Dibujar el diagrama de estados de la unidad de control y explicar qué señales de control se activarían en cada estado. Solución: La principal dificultad radica en el diseño de la ruta de datos con la restricción impuesta por el enunciado. Los elementos hardware que compondrán la misma son: 3 Registros para Almacenar A, B y Cont (es un registro normal de 8 bits). – 1 sumador/restador para hacer las operaciones de Cont*2 (Cont ! Cont), Decrementar Cont (Cont . 1) y la generación de la señal de comparación. Para esta señal se realiza la operación B . A y si el resultado empieza por 0 (R7 % 0) significará que la resta es positiva y que por tanto B n A que es la condición que el algoritmo debe evaluar.

126


Traduciendo el algoritmo al diagrama de flujo obtendremos fácilmente el diagrama de estados:


127

Y la tabla de salidas será: Estado

CB

CA

CC

M3

M2

M1

M0

Sumar/Restar

Fin

S0

0

1

1

0

X

X

X

X

0

S1

1

0

0

X

1

0

0

1

S2

0

0

1

1

1

0

1

0

S3

0

0

0

X

1

0

0

0

S4

0

0

0

X

X

X

X

X

0 1

PROBLEMA 3 La unidad de proceso dada implementa, entre otros, el siguiente algoritmo: while B a 0 do begin B p A ! 1; A p 2 . A; B p B/2; A p A S B; end;

Los registros A y B están inicializados a un valor dado antes de empezar a ejecutarse el algoritmo. C2

C1 C0

0 0 0

0 0 1

0 1 0

Op.

C2

C1

C0

Op.

A!1 A!B A@

0 1 1

1 0 0

0 0 1

BA C2(A) A SB

Se pide: a) Diseñar detalladamente la A.L.U. b) Diseñar la unidad de control (i.e.: dar un diagrama de flujo y una tabla de salidas).

128


Solución: a) La unidad aritmético-lógica debe seguir la tabla del enunciado. La parte más importante es la utilización del sumador. En el diseño de la figura se utiliza el sumador para realizar 3 operaciones: A ! 1. A ! B. C2(A): Para obtener el complemento a 2 invertimos bit a bit y sumamos 1.

Para obtener la señales de control de los multiplexores de entrada al sumador, sólo debemos simplificarlos de acuerdo a la tabla: C2 C1

C0 MA MB

0 0 0 0 1 1 1 1

0 1 0 1 0 1 0 1

0 0 1 1 0 0 1 1

0 0 X 1 X X X X

1 0 X 1 X X X X


b) Comencemos por el diagrama de flujo, traduciendo el algoritmo:

Las señales de control se pueden representar de la siguiente forma:

129

130



LB

LA

C2

C1

C0

Fin

S0

1

1

X

X

X

0

S1

0

0

1

1

1

0

S2

1

0

0

0

0

0

S3

0

1

0

1

0

0

S4

1

0

0

1

1

0

S5

0

1

1

0

1

0

S6

0

0

X

X

X

1

PROBLEMA 4 Diseñar una U.C. adecuada para que la U.P. de la figura ejecute el siguiente algoritmo: RegA: % A; RegB: % B; Repeat A % 2*A; B: % B/2; if A % B then B: % A ! B; Until B b A a) Realiza el diagrama de estados detallando las entradas y salidas. b) Realiza una tabla de salidas de la U.C. AYUDA: True es una señal de condición, resultado de las operaciones ‘ % ’ y ‘ b ’ y toma el valor 1 cuando A % B y A b B respectivamente.


131

Solución: De la ruta de datos especificada en el enunciado podemos obtener el diagrama de conexión entre la ruta de datos y la unidad de control.

132


Estado

SEL A

CA1

CA0

SEL B

CB1

CB0

ALU1

ALU0

Fin

S0

1

0

0

1

0

0

X

X

0

S1

X

1

1

X

1

1

1

1

0

S2

X

1

0

X

0

1

X

X

0

S3

X

1

1

X

1

1

1

0

0

S4

X

1

1

0

0

0

0

0

0

S5

X

1

1

X

1

1

X

X

1

PROBLEMA 5 Diseñar una U.P. y las conexiones a la U.C. para ejecutar el algoritmo con datos de 8 bits. Dibuja también el diagrama de estados de la unidad de control indicando qué valores toman las entradas y salidas. si (B n A) entonces C p 4*A sino C p (A ! B)/4


133

Solución: Partiendo del algoritmo necesitamos saber en primer lugar qué módulos hardware necesitamos: 3 registros para almacenar A, B y C. Además C debe permitir hacer desplazamientos para poder realizar las operaciones de multiplicación y división por 4 respectivamente. Recordemos que desplazar a la derecha (0 A) es equivalente a multiplicar por 2 y que desplazar hacia la izquierda (@ 0) da como resultado multiplicar por 2 el dato almacenado en el registro. Un comparador para saber si B n A. Un sumador para realizar la operación A ! B. A continuación debemos conectar estos elementos.

Las señales de control y de condición son por lo tanto: CB: Señal de carga del registro B. CA: Señal de carga del registro A. CC1: Señal de control 1 del registro C. CC0: Señal de control 0 del registro C. GE: Señal que indica que B % A. M: Selección del multiplexor. A partir del diagrama algorítmico podemos obtener casi de inmediato el diagrama de estados.

134



135


CB

CA

CC1

CC0

M

Fin

S0

1

1

0

0

X

0

S1

0

0

0

0

X

0

S2

0

0

0

0

1

0

S3

0

0

0

1

X

0

S4

0

0

0

1

X

0

S5

0

0

0

0

0

0

S6

0

0

1

0

X

0

S7

0

0

1

0

X

0

S8

0

0

1

1

X

1

PROBLEMA 6 Sea la U.P. de la figura. Diseñar la unidad de control necesaria para ejecutar el siguiente algoritmo. Para ello realizar el diagrama de estados indicando claramente las entradas y una tabla con las salidas en cada uno de ellos. A: % dato1;

B: % dato2;

While A % B B: % B . A; If B % 0 then A: % A/2; End

136


Solución:

Cód.

Op. ALU

0 0 1 1

A!B B.A AA Evalua B

0 1 0 1


137

138


Estado

MA

RA

MB

RB

OP

Fin

S0

1

1

1

1

XX

0

S1

X

0

X

0

01

0

S2

X

0

0

1

01

0

S3

X

0

X

0

11

0

S4

0

1

X

0

10

0

S5

X

0

X

0

XX

1

PROBLEMA 7 Diseñar algorítmicamente un sistema que realice operaciones sobre dos datos de 16 bits. El sistema tendrá como entrada, además de los operandos, un código que especifique cuál de las 4 operaciones fundamentales (suma, resta, multiplicación o división) debe realizar. El resultado se almacenará en un registro de resultado y el diseñador dispone de módulos de suma/resta y multiplicación/división ya implementados. Solución: La especificación del sistema en forma de bloques es la siguiente:

A partir de él podemos obtener fácilmente el algoritmo que debe manejarlo pero previamente debemos codificar las operaciones, dado que son 4 operaciones con 2 bits de código de operación será suficiente y podemos por ejemplo definirlo según la tabla siguiente: Código

Operación

00

Suma

01

Resta

10

Multiplicación

11

División


139

El algoritmo es inmediato: A: % Dato 1 B: % Dato 2 OP % Código de Operación If OP % ‘‘OO’’ then C % A ! B; else if OP % ‘‘01’’ C % A . B; else if OP % ‘‘10’’ C % A*B; else C % A/B end if

Con ello la ruta de datos debe tener los siguientes elementos: 2 registros de 16 bits para los operandos fuente A y B. Un registro de 32 bits para almacenar el resultado de las operaciones. El registro debe ser mayor ya que la operación de multiplicación puede generar datos mayores de 16 bits. Un Unidad Aritmético Lógica (ALU) que contenga al menos un sumador/restador y una unidad de multiplicación/división. Un registro de código de operación.

140


Si utilizamos el código almacenado en el registro OP, podemos diseñar una unidad de control más sencilla reduciendo el número de estados. Las señales de control serán: CA: señal de carga del registro RA que contiene uno de los operandos. CB: señal de carga del registro RB que almacenará el otro operando. CC: señal de carga del registro de resultado, en la figura RC. COP: señal de carga del registro OP que almacena el código de operación. En este caso el diagrama de estados es inmediato:

El estado S0 es el estado inicial y en él se cargan los datos en los registros, en el S1 se realiza el cálculo aritmético y se almacena el resultado y S2 es un estado final en el que el sistema permanecerá estable, almacenando el resultado, mientras no se reciba una señal de inicio para realizar otra operación. La tabla de salidas será por lo tanto la representada en la tabla siguiente: Estado

CA

CB

CC

COP

Fin

S0

1

1

0

1

0

S1

0

0

1

0

0

S2

0

0

0

0

1

Un aspecto interesante de este ejercicio es observar cómo un computador es al fin y al cabo un sistema algorítmico complejo. En este ejemplo se trata de un computador muy sencillo con 4 operaciones únicamente, pero que se codifican con un código de operación y unos operandos almacenados en registros. En los temas sucesivos se ampliarán estos conceptos para diseñar computadores y rutas de datos más complejas que constituyan lo que conocemos como máquinas sencillas.


141

PROBLEMA 8 Un cierto algoritmo se ejecuta en la UP dada siguiendo el diagrama de flujo mostrado. Programa la tabla de señales de control y construye el circuito secuencial que implementa el estado actual de la UC utilizando un contador y los elementos combinacionales que quieras. Indica el funcionamiento del registro R con una tabla.

Solución:

142


Estado

Q2Q1Q0

MAMB

LALB

R1R0

Fin

S0

000

11

11

00

0

S1

001

XX

00

00

0

S2

010

XX

00

11

0

S3

011

XX

00

01

0

S4

100

00

11

00

0

S5

101

XX

00

00

1

—

110

—

—

—

—

—

111

—

—

—

—


B0

Q2Q1Q0

E2E1E0

L

C

0

000

XXX

0

1

0

001

101

1

X

0

010

XXX

0

1

0

011

XXX

0

1

0

100

001

1

X

0

101

101

0

0

0

110

XXX

X

X

0

111

XXX

X

X

1

000

XXX

0

1

1

001

XXX

0

1

1

010

XXX

0

1

1

011

XXX

0

1

1

100

001

1

X

1

101

101

0

0

1

110

XXX

X

X

1

111

XXX

X

X

R1R0

Acción

00

Nada

01

A

10

@

11

Carga del dato

143

144


PROBLEMA 9 En la U.P. de la figura se desea ejecutar el siguiente algoritmo. a) Identificar y nombrar las señales de control y de condición sobre el dibujo de la U.P. b) Dibujar un diagrama de estados de la U.C. necesaria para ejecutar el algoritmo. c)

Programar la tabla de salidas de la U.C. RA p datoA; RB p datoB; while RA % RB RC p RB; RA p RC; RC p RA ! RB; end

Solución: a) Observando el algoritmo y la ruta de datos podemos deducir claramente las señales de carga de los registros y de los multiplexores. La parte más compleja es delimitar las señales que controlan la Unidad Aritmético Lógica (ALU). Para establecerlas veamos qué operaciones tiene que realizar dicha ALU: A . B para calcular si A % B, esto activará el bit Z (única señal de condición) que valdrá 1 cuando el resultado de la resta sea cero, es decir cuando A y B tengan el mismo valor.


145

A ! B para realizar la operación RC p RA ! RB. Dejar pasar RB para cargarlo en RC. Aunque no es necesario y dado que tenemos dos señales de control y están disponibles 4 opciones codificaremos también una combinación de las señales de control de ALU para dejar pasar el valor del registro RA. Las señales de control serán por lo tanto M1 para el multiplexor de paso a RA, M2 para el multiplexor de paso a RB, LA señal de carga del registro RA, LB señal de carga del registro RB, LC señal de carga del registro RC, y OP1OP0 para controlar la ALU de acuerdo a la siguiente tabla: OP1OP2

Acción de la ALU

00

Pasa A

01

A!B

10

A.B

11

Pasa B

La figura muestra dónde van conectadas las señales de control en la ruta de datos.

146


Y el esquema general de conexión entre la ruta de datos y la unidad de control será por lo tanto:

b) Como en el resto de problemas obtenemos en primer lugar el diagrama de flujo del algoritmo a partir del cual obtendremos el diagrama de estados, casi de inmediato.


c)

147

La tabla de salida para este diagrama de estados incluyendo la señal de FIN de operación será la siguiente. Se incluye también en la tabla la codificación escogida para los estados (q2 q1 q0). Estado

Q2Q1Q0

M1

M2

LA

LB

LC

OP1OP0

Fin

S0

000

1

1

1

1

0

XX

0

S1

001

X

X

0

0

0

10

0

S2

010

X

X

0

0

1

11

0

S3

011

0

X

1

0

0

XX

0

S4

100

X

X

0

0

1

01

0

S5

101

X

X

0

0

0

XX

1

—

110

—

—

—

—

—

—

—

—

111

—

—

—

—

—

—

—

148


PROBLEMA 10 Diseñar la unidad de proceso y su correspondiente unidad de control para ejecutar el siguiente algoritmo: Algoritmo: A: % dato1;

B: % dato2;

C % dato3

if A % B if C % 2 B: % B*2; else B % B/2 endif else A: % A/2; endif Para ello realizar el diagrama de estados indicando claramente las entradas y una tabla con las salidas en cada uno de ellos. Realizar la implementación completa del sistema. Solución: Lo primero que hay que identificar son los elementos hardware que necesitamos. En este caso necesitaremos tres registros para almacenar los datos, un comparador de A y B, un comparador de C con 2. Si los registros A y B son de desplazamiento, pueden realizar las operaciones de multiplicación y división por lo que no haría falta ningún módulo hardware adicional. El organigrama del algoritmo es


149

Si no tenemos ninguna restricción podemos cargar los datos después de compararlos aunque esto no es lo más seguro, como regla general intentaremos tener almacenados los datos para poder partir de un estado inicial de borrado. En este organigrama los estados se identificarían con los rectángulos ya que son almacenamiento de valores en registro.

Estado

S1

S0

C0A

C1A

C0B

C1B

C0C

C1C

Fin

S0

0

0

0

0

0

0

0

0

0

S1

0

1

1

1

0

1

1

1

1

S2

1

0

1

1

1

0

1

1

1

S3

1

1

0

1

1

1

1

1

1

C0A % S0 S S1 C1A % S0 ! S1 C0B % S1 C1B % S0 C0C % C1C % C1A % Fin

150


Inicio

IG1

IG2

S1

S0

S1(T ! 1)

S0(T ! 1)

0

0

0

0

0

1

1

0

0

0

0

1

0

1

0

0

0

1

0

1

0

0

0

0

1

1

1

1

0

0

1

0

0

1

1

0

0

1

0

1

0

1

0

0

1

1

0

1

0

0

0

1

1

1

1

1

0

1

0

0

0

1

0

0

1

0

0

1

0

1

0

1

0

1

0

1

0

0

1

0

1

1

1

1

0

1

1

0

0

0

1

0

1

1

0

1

0

1

0

1

1

1

0

1

0

0

1

1

1

1

1

1

1

0

0

0

0

0

0

1

0

0

0

1

0

0

1

0

0

1

0

0

0

1

0

0

1

1

0

0

1

0

1

0

0

0

0

1

0

1

0

1

0

0

1

0

1

1

0

0

0

1

0

1

1

1

0

0

1

1

0

0

0

0

0

1

1

0

0

1

0

0

1

1

0

1

0

0

0

1

1

0

1

1

0

0

1

1

1

0

0

0

0

1

1

1

0

1

0

0

1

1

1

1

0

0

0

1

1

1

1

1

0

0

Esta tabla se podría simplificar añadiendo un estado.


151

Ahora debemos simplificar las señales de cambio de estado. Mediante mapas de Karnaugh podemos llegar a las expresiones siguientes: S1(t ! 1) % Inicio . (S1 ! S0 . IG2 ! S0 . IG1) S0(t ! 1) % Inicio . (S0 ! S1 . IG2 ! S1 . IG1) PROBLEMA 11 Diseñar el sistema de cambio de una máquina automática que reciba monedas de 2 euros, 1 euro, 50 céntimos, y 20 céntimos. El sistema dispone de monedas de 1 euro y 50, 20 y 10 céntimos. Para la ruta de datos se utilizarán 4 contadores y un registro que almacenen el importe de entrada y el cambio. Solución: Lo primero que debemos hacer es obtener el algoritmo, para ello establecemos que el valor de la moneda de entrada se almacena en una variable M. También debemos establecer una estrategia de cambio, es decir cuántas monedas de cada tipo vamos a proporcionar. Nuestra decisión se encuentra recogida en la tabla siguiente en la que la variable U expresa el número de monedas de 1 euro, C el número de monedas de 50 céntimos, V el número de monedas de 20 céntimos y D el número de monedas de 10 céntimos que se van a devolver: Moneda

M

U

C

V

D

2e

00

2

0

0

0

1e

01

0

2

0

0

0,50 e

10

0

0

2

1

0,20 e

11

0

0

0

2

El algoritmo será por tanto: M % Data in if M % 0 then U % 2; else if M % 1 then C % 2; else if M % 2 then V % 2; D % 1; else D % 2; end if Cada uno de los registros contadores se activará con una señal y al final del proceso deberá contener un valor igual a la cantidad de monedas que debe devolver el sistema. La ruta de datos en este caso es muy sencilla:

152


En la ruta de datos M1M0 codifican en binario el tipo de moneda recibido atendiendo a la tabla anterior (columna M). En un sistema real esto se implementaría utilizando un sistema mecánico que recibiera las monedas en función de su peso. Traduciendo el algoritmo a un diagrama nos queda definido igualmente el diagrama de estados.


153

Y la tabla de salidas para cada estado será: Estado Cargar M Contar U Borrar U Contar C Borrar C Contar V Borrar V Contar D Borrar D

Fin

S0

1

0

1

0

1

0

1

0

1

0

S1

0

0

0

0

0

0

0

0

0

0

S2

0

1

0

0

0

0

0

0

0

0

S3

0

0

0

1

0

0

0

0

0

0

S4

0

0

0

0

0

1

0

0

0

0

S5

0

0

0

0

0

0

0

1

0

0

S6

0

1

0

0

0

0

0

0

0

0

S7

0

0

0

1

0

0

0

0

0

0

S8

0

0

0

0

0

1

0

0

0

0

S9

0

0

0

0

0

0

0

0

0

0

S10

0

0

0

0

0

0

0

1

0

1

PROBLEMA 12 Dada la siguiente UC y la tabla de señales de estado, obtener una ruta de datos que sea factible con ellas. Se permite incorporar señales de control de multiplexores si fueran necesarios.

OP1OP0

Operación ALU

00

A.C

01

A.B

10

A!B

11

A!C

154


Estado

Q2Q1Q0

OP1OP0

LALBLC

Fin

S0

000

XX

111

0

S1

001

01

000

0

S2

010

10

100

0

S3

011

00

000

0

S4

100

11

010

0

S5

101

10

001

0

S6

110

XX

000

1

—

111

—

—

—

Solución: Como resulta evidente del planteamiento del problema existen múltiples soluciones a este problema, pero lo interesante es analizar las señales y comprender su significado. Iremos analizando la tabla y sacando conclusiones para poder obtener una ruta de datos que sea coherente con el enunciado. En primer lugar, parece claro que existen 3 registros A, B y C que se corresponden con las señales de carga LA, LB y LC. Parece también claro que existe una unidad aritmético lógica (ALU) que realiza las operaciones de suma y resta de estos registros. Por lo tanto en cada estado se realizará en la ALU la operación que indiquen los valores de operación OP1 y OP0, y el resultado de esta operación se almacenará en el registro cuya señal de carga L, esté a 1. Por ejemplo: Estado

Q2Q1Q0

OP1OP0

LALBLC

Fin

S2

010

10

100

0

Los valores de las señales de control mostrados en esta fila nos indican que: El estado S2 se codifica como 010. Que según la tabla del enunciado OP1OP0 corresponde con la operación A ! B en la ALU. Y que el registro A se cargará un valor (LA % 1), previsiblemente el resultado de la operación realizada en la ALU y así lo supondremos. Observando el diagrama de estados también podemos deducir que el estado 1 y 3 son estados donde se evalúan condiciones. Esto concuerda también con la tabla de salidas, ya que para estos estados todas las señales de carga están a cero. Del enunciado podemos saber que se evalúan las condiciones ¿A % B? y ¿A % C? respectivamente. La ALU en estos casos realiza una operación de resta según los códigos OP1OP0 asignados para la ALU. Por lo tanto debe existir una señal de condición (Z) que indique si el resultado de la operación ha sido cero. Siguiendo el convenio habitual si la operación ha sido cero Z % 1 y Z % 0 en caso contrario. Siguiendo con este razonamiento podemos deducir qué sucede en todos los estados y podemos así establecer el algoritmo. Una posible solución sería:


Y la ruta de datos que realice el algoritmo podría ser la siguiente:

155

156


PROBLEMA 13 Se desea diseñar un computador sencillo que codifique las instrucciones en dos registros. Por un lado un registro de 24 bits almacenará en 3 campos los valores de tres operandos A, B y C. Y por otro lado un registro de 5 bits especificará en 2 campos la operación a realizar (suma, resta, multiplicación y división) y qué registro es el operando destino. Para esto último utilizará un código de 3 bits (uno para A, otro para B y otro para C) en el que un valor de «1» indicará que se trata de un operando fuente y un valor de «0» que actúa como operando destino. Se pide: a) Diseñar los dos registros implicados. b) Definir el algoritmo. c) Diseñar un diagrama de la ruta de datos. Solución: a) Los registros que hay que diseñar son el equivalente a los registros de instrucciones de un computador sencillo. El primer registro deberá tener la siguiente definición de campos: Operando A (8 bits)

Operando B (8 bits)

Operando C (8 bits)

El segundo registro tendrá la siguiente forma: OP1OP0

D2D1D0

Este registro debe llevar asociado un detector de códigos erróneos. Según el enunciado si debemos tener 2 operandos fuente y uno destino tendremos 5 combinaciones de código que no representan configuraciones válidas. Por ejemplo, un código 001 indicaría que el operando B y el A son operandos fuentes, lo cual no es compatible con las operaciones definidas en la especificación funcional. La tabla de detección de errores será: D2D1D0

Error

Operando destino

000

1

ññññññ

001

1

ññññññ

010

1

ññññññ

011

0

A

100

1

ññññññ

101

0

B

110

0

C

111

1

ññññññ

La señal de error será por lo tanto: Error % D1D0 ! D2D1 ! D2D0 ! D2D1D0


157

b) Para definir el algoritmo utilizamos como valores de entrada los de los registros diseñados en el apartado anterior. A: % Dato 1 B: % Dato 2 OP % Código de Operación If Error % ‘‘1’’ then Fin else if OP % ‘‘00’’ C % A ! B; else if OP % ‘‘01’’ C % A . B; else if OP % ‘‘10’’ C % A*B; else C % A/B end if end if

c)

La ruta de datos será:

158


Las señales de control que debe suministrar la unidad de control son: LROP: Cargar datos en el registro de operandos. LC: Cargar datos en el registro de códigos de operación y fuentes-destino. M1 a M7: Selección de operandos y destinos. Y por otro lado la unidad de control debe recibir D2D1D0 para generar la señal de error definida en el apartado a). PROBLEMA 14 Diseñar un sistema algorítmico que realice la suma de 4 valores de 8 bits, utilizando únicamente un registro denominado RR (Registro de Resultados), un sumador y un multiplexor de 8 bits para la ruta de datos. Diseñar la unidad de control de tal forma que sólo se permita reiniciar el sistema si se ha llegado al final del proceso de suma de los 4 valores. Utilizar un contador módulo 8 para implementar la unidad de control. El registro RR se borra de forma síncrona. Solución: Dado que sólo tenemos un registro los 4 datos tendrán que estar disponibles durante todo el proceso y la única forma de ir incorporándolos es multiplexándolos. El algoritmo a seguir deberá ir haciendo sumas parciales y almacenándolas en el único registro disponible RR.

El primer paso en realidad se podría eliminar ya que podría cargarse directamente el valor de Dato 1 en el registro y con eso quedaría eliminado el valor anterior. Sin embargo, dado que los datos de entrada no van a estar almacenados en un registro conviene hacer un borrrado del registro al mismo tiempo que se comienza la ejecución del algoritmo.


159

Las señales de control serán en este caso las habituales de carga (LR) y borrado del registro (BR) y las señales del control de multiplexor M1M0. El diagrama de estados debe tener en cuenta que sólo se puede reiniciar el proceso si se ha llegado hasta el final, en ese caso quedaría de la siguiente forma:

La implementación de la unidad de control con el contador es directa, sólo tenemos que conectar la señal de cuenta (C) y de carga (L). Los valores que se obtienen son: C%1 L % q2q1q0 e2 % e0 % Inicio . q2q1q0 e1 % 0 FIN % q2q1q0 Por otro lado, la tabla de valores de las señales de control para cada estado será: Estado

q2q1q0

M1M0

LR

BR

Fin

S0

000

XX

0

1

0

S1

001

00

1

0

0

S2

010

01

1

0

0 continúa

160


continuación S3

011

10

1

0

0

S4

100

11

1

0

0

S5

101

XX

0

0

1

—

110

—

—

—

—

—

111

—

—

—

—

Podemos igualmente obtener las ecuaciones que relacionen las señales de control con el estado de la unidad de control sin más que simplificar las expresiones por mapas de Karnaugh de la tabla anterior. LR % q1 ! (q2 S q0) CR % q2 ! q1 ! q0 M1 % q2 ! q1q0 M0 % q0 En este caso resulta fácil diseñar el sistema completo, conectando completamente la unidad de control y la ruta de datos:


161

PROBLEMA 15 Diseñar un sistema que permita calcular potencias de 2. El sistema debe disponer de una entrada que permita especificar la potencia que se pretende calcular entre 20 y 215 y el resultado quedará almacenado en un registro. Solución: La especificación algorítmica es prácticamente equivalente al diagrama de flujo que tendrá la forma siguiente:

Para implementar la ruta de datos necesitaremos: Un registro de 15 bits para almacenar el resultado (RR). Un registro contador de 4 bits para especificar el exponente (Cont).

162


Las señales de control enviadas desde la unidad de control serán: LR: Cargar dato en el registro. DR: Desplazamiento hacia la izquierda. BC: Borrar el contador. C–: Cont % Cont-1. Y la señal de condición (Z) indicará cuándo el contador ha llegado a cero. Sólo nos queda diseñar la unidad de control, que será una máquina de Moore con 5 estados siguiendo el esquema del diagrama de flujo. Incorporamos en este caso una señald de Inicio.

PROBLEMA 16 Diseñe la ruta de datos de un sistema secuencial que implemente el siguiente al algoritmo: if A n B then C: % 2B . A/4; else C: % ((A ! B)*4); Los datos de entrada y de salida son de 8 bits. Especifique las señales de control necesarias para gobernar el procesador. Solución: En este caso debemos traducir el algoritmo a un diagrama de flujo y a partir de ahí obtener la ruta de datos y las señales de control que se enviarán a la unidad de control.


163

Si dibujamos la ruta de datos obtendremos que las señales de control son las que aparecen en la figura: LA: señal de carga del registro RA que contiene uno de los operandos. LB: señal de carga del registro RB que almacenará el otro operando. LC: señal de carga del registro de resultado, en la figura RC. DA: señal de carga del registro RA que contiene uno de los operandos. DB: señal de carga del registro RB que almacenará el otro operando. DC: señal de carga del registro de resultado, en la figura RC. !/.: Señal de suma y resta del sumador para realizar A ! B o A . B.

164


PROBLEMA 17 Un sistema secuencial recibe dos datos de entrada X e Y expresados en complemento a 2 y con un tamaño de 8 bits, proporcionando el resultado de la operación: Z % X*(X . 1)*(X . 2) si X b Y Z % Y*(Y . 1)*(Y . 2) si X m Y Diseñar el algoritmo que realice la operación y hacer una implementación de la ruta de datos. Definir la función de salida y cambio de estado de la unidad de control teniendo en cuenta que se diseñará como una máquina de Mealy. Solución: El diagrama de flujo del algoritmo debemos pensarlo teniendo en mente utilizar el menor número de módulos hardware posible. Al ser la unidad de control diseñada como máquina de Mealy, podemos tener varias opciones dentro de cada estado, ya que lo que cambiará serán las señales de salida en las transiciones. Con esto el algoritmo propuesto queda de la siguiente forma:


165

Y la ruta de datos necesitará los siguientes elementos: 2 registros de 9 bits que almacenen X y Y (RX y RY). Aunque los números son de 8 bits tenemos que tener en cuenta que al tener almacenada una información en complemento a 2 al restar uno al valor más pequeño podemos necesitar un bit más para representarlo. Un registro de 16 bits para almacenar el resultado de la multiplicación (RC). Un sumador/restador para realizar la operación X % X . 1. Un multiplicador de números de 8 bits. Multiplexores para seleccionar la información.

166


A este diseño de la ruta de datos cabría hacerle una salvedad relativa al almacenamiento del resultado de la comparación X b Y?. Dado que este valor lo proporciona un módulo combinacional y que éste se modifica cada vez que lo hacen sus entradas, habría que tener prevista la inclusión de un registro que sólo cargara el valor en el estado S1. Sin embargo, es posible eliminar ese registro, y por lo tanto un estado, si lo tenemos en cuenta a la hora de diseñar la unidad de control. En este caso habría que hacer que la transición entre los estados S1, S2 y S3 se realizara conforme al valor inicial que lee la unidad de control y no chequeando en cada transición. Por lo tanto la unidad de control debería guardar ese valor en un registro interno o

167


registro de estado correspondiente, lo que en la práctica es equivalente a realizar el diseño como una máquina de Moore. Para esta unidad de control lo interesante es definir las funciones de salidas asociadas a cada transición, ya que es la principal diferencia con respecto a los ejercicios que se han resuelto en este capítulo que utilizan como diseño una máquina de Moore. La función de salida incluirá las señales de control que aparecen en la figura anterior y una señal de Fin de cálculo. Para mejorar la compresión se omite cualquier posible señal de Inicio o borrado de registros, pero, como ya se ha comentado, el lector debe tener en cuenta que estas señales deben implementarse para poder reiniciar el sistema: XbY

Q2

Q1

Q0

MX

LX

MY

LY

MC

LC

MR

Fin Q2(t ! 1) Q1(t ! 1) Q0(t ! 1)

0

0

0

0

1

1

1

1

X

0

X

0

0

0

1

0

0

0

1

X

0

0

1

1

1

1

0

0

1

0

0

0

1

0

X

0

0

1

0

1

1

0

0

1

1

0

0

1

1

X

0

0

0

0

1

1

0

1

0

0

0

1

0

0

X

0

X

X

X

0

X

1

1

0

0

0

1

0

1

X

X

X

X

X

X

X

X

X

X

X

0

1

1

0

X

X

X

X

X

X

X

X

X

X

X

0

1

1

1

X

X

X

X

X

X

X

X

X

X

X

1

0

0

0

0

1

1

1

X

0

X

0

0

0

1

1

0

0

1

0

1

X

0

1

1

0

0

0

1

0

1

0

1

0

0

1

X

0

0

1

0

0

0

1

1

1

0

1

1

0

1

X

0

0

1

0

0

1

0

0

1

1

0

0

X

0

X

0

X

0

X

1

1

0

0

1

1

0

1

X

X

X

X

X

X

X

X

X

X

X

1

1

1

0

X

X

X

X

X

X

X

X

X

X

X

1

1

1

1

X

X

X

X

X

X

X

X

X

X

X

168


PROBLEMA 18 Diseñar algorítmicamente un multiplicador de números de 16 bits. El algoritmo viene determinado por el siguiente diagrama. En él, RMP representa el registro multiplicador, RMD es el registro multiplicando y RP es el registro producto. Explique cómo se podría mejorar este diseño.


169

Solución: En este caso no necesitamos obtener la descripción algorítmica, ya que viene especificada por el esquema que nos proporciona el enunciado. En cualquier caso conviene familiarizarse con el funcionamiento del proceso, para ello veamos en una tabla cómo se realiza la multiplicación de dos números de 4 bits: 0110 # 0011 % 0110 en binario (6 # 3 % 18) en decimal. I

RMP

RMD

RP

RMP % 0?

I % 4?

0

(0110)2 % (6)10

(0011)2 % (3)10

(00000000)2 % (0)10

SI

NO

1

(0011)2 % (3)10

(00110)2 % (6)10

(00000000)2 % (0)10

NO

NO

2

(0001)2 % (1)10

(001100)2 % (12)10

(00000110)2 % (6)10

NO

NO

3

(0000)2 % (0)10

(0011000)2 % (24)10

(00010010)2 % (18)10

SI

NO

4

(0000)2 % (6)10

(00110000)2 % (48)10

(00010010)2 % (18)10

XX

SI

De nuevo es importante tener en cuenta la forma de definir la unidad de control. Si lo hacemos como máquina de Mealy en el momento en que i sea igual a 4 pasará al estado final y se debe implementar una señal de Fin. Comencemos con el diseño propiamente dicho. Selección y conexión de los módulos de la ruta de datos Observando el diagrama necesitaremos los siguientes elementos: Dos registros de 16 bits para almacenar el multiplicador y el multiplicando y que denominaremos RMP y RMD respectivamente para seguir la nomenclatura del enunciado. Los registros deberán permitir realizar desplazamiento para realizar las operaciones (RMD @ 0) y (0 A RMP). Un registro de 32 bits para almacenar el resultado, RP. Un registro contador de 5 bits para almacenar e incrementar el valor de i. Un comparador para saber si se ha llegado a la última iteración. Un sumador de 32 bits para realizar la operación RP % RMD ! RP. Un extensor de signo (EXT) para operar con datos de 32 bits.

170


La forma de conectarlos será la siguiente:

Selección de las señales de control y de condición Las señales de control serán las necesarias para controlar los elementos anteriores. Siguiendo el mismo orden: LRMP: Carga del Registro Multiplicador, RMP. DRMP: Desplazamiento del Registro Multiplicador, RMP. LRMD: Carga del Registro Multiplicador, RMD. DRMD: Desplazamiento del Registro Multiplicando, RMD. LRR: Carga del Registro de Resultado, RR. CONTAR: Avance del contador i. BORRADO: Inicialización del contador. FIN: Salida de control que indica el final del proceso. Y las señales de condición serán: RMP0 PROCESAR


171

Definición de los distintos estados del procesador La implementación se va a realizar siguiendo la organización del diagrama de flujo y considerando la unidad de control como una máquina de Moore.

Especificación de las salidas para cada estado Estado

q2q1q0

LRMP

DRMP

LRMD

DRMD

LRP

Contar

Borrado

Fin

S0

000

1

0

1

0

0

0

1

0

S1

001

0

0

0

0

0

0

0

0

S2

010

0

0

0

0

1

0

0

0

S3

011

0

0

0

1

0

0

0

0

S4

100

0

1

0

0

0

0

0

0

S5

101

0

0

0

0

0

1

0

0

S6

110

0

0

0

0

0

0

0

0

S7

111

0

0

0

0

0

0

0

1

172


Implementación de la unidad de control como sistema secuencial La implementación de la unidad de control con el contador es directa, sólo tenemos que conectar la señal de cuenta (C) y de carga (L). Los valores que se obtienen son: C%1 L % PROCESAR . S2 . S1 ! S2 . S1 . S0 ! RMP . S2 . S1 . S0 e2 % S1 . S0 e1 % q1 e0 % 1 FIN % q2 . q1 . q0 Para completar el diseño sólo debemos realizar la implementación de estas ecuaciones de la misma forma que se hace en el problema 14. Mejora del diseño Para mejorar el diseño deberíamos reagrupar los estados S4, S5 y S6, ya que se realizan en recursos hardware independientes y no es necesario hacerlos en ciclos separados. PROBLEMA 19 Diseñar un sistema algorítmico que realice la operación 2A ! 2B utilizando un único registro. Solución: Una posible solución sería reutilizar el diseño del problema 14 y cambiar las entradas. Para reutilizar también la unidad de control deberíamos dejar el diseño como sigue.


173

PROBLEMA 20 Diseñar un sistema algorítmico que realice la operación 2A ! 8B utilizando dos registros y elementos combinacionales. Solución: En este caso podemos obtener en primer lugar el algoritmo adaptado al uso de registros de desplazamiento para realizar las operaciones será: A % Dato 1; B % Dato 2; A % 2*A; B % 2*B; B % 2*B; B % 2*B; A % A ! B;

174


Utilizando los elementos que nos indica el enunciado debemos conectarlos de la siguiente forma para que realicen el algoritmo indicado en el diagrama de flujo.

Y la unidad de control enviará las señales de control indicadas en el siguiente esquema.

El diagrama de estados será simple y sin bifucarciones ya que no existen decisiones a tomar ni señales de control de las que dependa el flujo de datos. Identificando cada bloque del diagrama de datos con un estado de la unidad de control obtenemos el siguiente diagrama de transición de estados en el que está incluida la señal de Inicio del proceso que sólo se puede activar en el estado final.


175

Y la tabla de salidas de control será: Estado

Q2Q1Q0

M

LA

DA

LB

DB

Fin

S0

000

1

1

0

1

0

0

S1

001

X

0

1

0

1

0

S2

010

X

0

0

0

1

0

S3

011

X

0

0

0

1

0

S4

100

0

1

0

0

0

1

—

101

—

—

—

—

—

—

—

110

—

—

—

—

—

—

—

111

—

—

—

—

—

—

4.4 Problemas propuestos PROBLEMA 1 Diseñar un sistema algorítmico que realice la operación (nA ! mB) utilizando dos registros y elementos combinacionales, para valores de n y m potencias de 2 (entre 20 y 27). PROBLEMA 2 Diseñar un sistema secuencial que calcule el factorial de un número positivo de 16 bits. PROBLEMA 3 Diseñar la unidad de control y definir la tabla de salidas del problema resuelto n.o 13. Definir también el diagrama de conexiones entre la unidad de control y la unidad de proceso, especificando además las señales de entrada, señales de salida, entradas y salidas de control. PROBLEMA 4 Un sistema secuencial recibe dos datos de entrada X e Y expresados en complemento a 2 y con un tamaño de 8 bits, proporcionando el resultado de la operación: X ! (X . 1) ! (X . 2) ! (Y . 1) ! (Y . 2)

176


Diseñar algorítmicamente el sistema. Para ello deberá definir la ruta de datos y el diagrama de estados con su tabla de salidas. La unidad de control se diseñará como una máquina de Moore. PROBLEMA 5 Diseñar algorítmicamente un sistema que realice la operación 2A ! 2B utilizando todos los elemento que estime oportuno. PROBLEMA 6 Diseñar un sistema que implemente el siguiente algoritmo IF (A % B % C) THEN C % C/2; ELSE IF (A % B) THEN B % B ! C; ELSE IF (A % C) THEN A % A ! B; ELSE A % A ! C ! B; ENDIF PROBLEMA 7 Rediseñar la unidad de control del problema resuelto n.o 18 para que el multiplicador tarde menos ciclos en proporcionar el resultado. PROBLEMA 8 Diseñar un sistema que permita calcular potencias de 3. El sistema debe disponer de una entrada que permita especificar la potencia que se pretende calcular entre 30 y 315 y el resultado quedará almacenado en un registro. Utilice un multiplicador como el diseñado en el problema 18. ¿Cuántos ciclos tardaría el sistema en devolver el valor de 37? PROBLEMA 9 Dada la U.P., diseñar la unidad de control (diagrama de estados y tabla de salidas) para ejecutar el siguiente algoritmo: B p mem; while z % 1 A p B ! mem end


177

PROBLEMA 10 Diseñar un contador gobernado por dos señales A y B que indiquen si la cuenta se realiza de uno en uno o de dos en dos.

a

Aunque en capítulos sucesivos se van a estudiar en mayor profundidad los conceptos de estructura de computadores, es conveniente que, una vez desarrollados todos los conceptos de sistemas combinacionales y secuenciales, se realice una primera aproximación a un computador sencillo. Este computador está basado en la arquitectura de Von Neumman. En la mayoría de textos de Fundamentos de Computadores se suele utilizar el modelo estándar de la Máquina Rudimentaria (MR), que sirve como base para los ejercicios de este capítulo. La máquina rudimentaria ha sido desarrollada por la Universidad Politécnica de Cataluña y se encuentra desarrollada en profundidad en el texto de Hermida, Corral, Pastor y Sánchez (2000). Como se ha visto en el capítulo anterior, un procesador, ya sea simple o más complejo, se compone de dos elementos fundamentales: una Unidad de Proceso y una Unidad de Control (UC). Por ello, definiremos a continuación las características del computador sencillo que vamos a utilizar, especificando y detallando las características de su UP y su UC.

5.1 Diseño de la unidad de proceso La memoria es de 28 palabras de 16 bits, por lo tanto tendrá un bus de direcciones de 8 bits, un bus de entrada de datos de 16 bits, un bus de salida de datos también de 16 bits y una señal de lectura/escritura. Los datos leídos estarán disponibles en el bus de salida y el almacenamiento de los datos en la memoria se hará a través del bus de entrada. El Registro de Instrucciones (IR) almacena la instrucción que se está ejecutando. Puesto que las instrucciones se guardan en la memoria, ésta saldrá por el bus de salida de la memoria para llegar al IR. El tamaño del IR será de 16 bits. Para leer una instrucción (o un dato) es necesario indicar la dirección de memoria en que se encuentra. En el caso de las instrucciones la dirección estará, generalmente, en el registro contador de programa (PC). Si la instrucción no está en ese registro estará en el registro auxiliar de direcciones (R@). Por lo tanto el PC tendrá un ancho de 8 bits para poder acceder a las 28 palabras de la memoria y su salida estará conectada al bus de direcciones de la memoria. Como se trata de una máquina en la que la siguiente instrucción en memoria será la próxima

180


Estructura general de la Máquina Rudimentaria.

Capítulo 5 Estructura de un computador sencillo

181

instrucción a ejecutar (salvo para instrucciones de salto), el PC debe tener capacidad de autoincremento. El banco de registros es de 8 posiciones de 16 bits. Tiene «bus» de datos de entrada, de salida, una señal de escritura, y dos buses de direcciones, uno para seleccionar el registro de lectura y otro para seleccionar el de escritura. Dado que tenemos 8 registros, estos buses de direcciones son de 3 bits. La Unidad Aritmético Lógica (ALU) realiza las operaciones aritmético-lógicas y modifica los registros de estado N y Z. El registro N valdrá 1 cuando el resultado de la última operación haya sido negativo y 0 en caso contrario. Por su parte, el registro Z valdrá 1 cuando el resultado de la última operación haya sido cero y tomará el valor de 0 si el resultado ha sido distinto de cero. Existen dos tipos de operaciones aritmético-lógicas: las que operan con dos valores almacenados en registros del banco y las que operan con un valor de un registro y un operando inmediato. El operando inmediato estará grabado en la instrucción, y como hemos indicado, ésta se encuentra almacenada en IR. Por lo tanto, el operando tendrá que ir desde el IR a una entrada de la ALU, extendiendo previamente el signo para llegar a los 16 bits con los que opera la ALU (ya que en la instrucción sólo ocupa 5 bits). El otro operando estará guardado en un registro y por lo tanto el dato saldrá del banco de registros e irá a la otra entrada de datos de la ALU. Debido al formato de instrucción que hemos elegido tenemos 3 posibilidades de lectura del banco de registros. Podemos querer leer del RF1 (Registro Fuente 1, que coincide con los bits del RI de las instrucciones de LOAD), del RF2 (Registro Fuente 1), o del RF cuando se trata de la instrucción Store. Estas tres posibilidades se traducen en 3 líneas, de 3 bits cada una, que son las entradas del multiplexor de la entrada de selección de lectura (SL) en el banco de registros.

5.2 Diseño de la ALU La Unidad Aritmético Lógica (ALU) actúa en las instrucciones Aritmético-Lógicas y en Load. En esta última el dato viene de memoria por el bus y llega a la ALU por la entrada de la derecha (atravesando el multiplexor correspondiente). En la ALU se realizan todas las operaciones al mismo tiempo y luego se selecciona la solicitada por la instrucción mediante un Multiplexor de salida. Aunque esta solución no es la más eficiente en términos de energía, sí que resulta la más apropiada para una primera aproximación al diseño de unidades funcionales y aritmético-lógicas. El esquema de la Unidad Aritmético-Lógica incluida en la Máquina Rudimentaria es el siguiente:

182


5.3 Formato de las instrucciones El formato de las instrucciones que vamos a considerar es el siguiente: Tipo de instrucción

Formato de instrucción de 16 bits

ALU entre registros

Código IR15-14

RD IR13-11

RF1 IR10-8

RF2 IR7-5

XX IR4-3

ALU entre registro e inmediato

Código IR15-14

RD IR13-11

RF1 IR10-8

Salto

Código IR15-14

COND IR13-11

000 IR10-8

Dirección IR7-0

STORE

Código IR15-14

RD IR13-11

RI IR10-8

Dirección IR7-0

LOAD

Código IR15-14

RF IR13-11

RI IR10-8

Dirección IR7-0

ⲆNUM IR7-3

OP IR2-0 OP IR2-0


Tipo de instrucción

Código IR15-14

LOAD

00

STORE

01

Salto

10

ALU entre registro e inmediato

11

ALU entre registros

11

Instrucción en lenguaje ensamblador

CC

Condición a evaluar

Tipo de salto

BR dirección

000

1

Incondicional

BEQ dirección

001

Z

Salto SI resultado % 0

BL dirección

010

N

Salto SI resultado a 0

BLE dirección

011

N(OR)Z

Salto SI resultado m 0

BNE dirección

101

NOT(Z)

Salto SI resultado Ç 0

BGE dirección

110

NOT(N)

Salto SI resultado n 0

BG dirección

111

NOT(N (OR) Z)

Salto SI resultado b 0

Instrucción

Tipo (IR15IR14)

OP % IR2IR1IR0

ADDI

11

000

SUBI

11

001

ADD

11

100

ADDI

11

101

ASR

11

110

AND

11

111

183

5.4 Diseño de la unidad de control La unidad de control utilizada será la de la máquina rudimentaria simplificada cuyo diagrama de transición de estados tiene por señales de control de la transición EVAL y el tipo de operación, es decir IR15IR14. El diagrama de transición de estados es:

184


Las instrucciones realizan las siguientes fases: Instrucción

Estados

ADDI

FETCH* ! DECO ! ARIT

SUBI


ADD


ADDI


ASR


AND


LOAD

FETCH* ! DECO ! LOAD

STORE

FETCH* ! DECO ! STORE

BR

FETCH* ! DECO ! SALTO

BEQ

FETCH* ! DECO ! SALTOⱅ

BL


BLE


BNE


BGE

FETCH* ! DECO ! ALTOⱅ

BG


* La fase de FETCH no se realiza si la instrucción anterior fue ARIT o SALTO ya que en esas fases ya se realiza la carga del registro de instrucciones y la actualización del contador de programa. ⱅ La fase de SALTO se realiza sólo en caso de que la señal EVAL sea igual a 1 como muestra el diagrama de transición de estados.

185


Las señales de control serán las que realicen las siguientes operaciones en cada fase o estado: Estado de la UC

Operaciones que se realizan

FETCH

Carga de la instrucción en el IR Actualización del PC

DECO

Lectura del primer operando Cálculo de la dirección efectiva Evaluación de la condición de salto

LOAD

Escritura desde la memoria en el RD Selección de la dirección Escritura en memoria desde el RF

STORE

Lectura del segundo operando y ejecución en la ALU Carga de la instrucción en el IR Actualización del PC

ARIT

Carga de la instrucción destino del salto en el IR Actualización del PC

SALTO

Estado de la UC

LPC CRF

E

LR@ C@ R/W

LN

LZ

LAUX ALU LIR

FETCH

1

X

0

0

0

0

0

0

0

X

1

DECO

0

1

0

1

X

0

0

0

1

X

0

LOAD

1

2

1

0

0

0

1

1

0

1

1

STORE

0

X

1

0

1

0

1

1

0

0

0

ARIT

0

0

0

0

1

1

0

0

0

X

0

SALTO

1

X

0

0

1

0

0

0

0

X

1

NOTA ACLARATORIA En otros textos que utilizan como referencia la máquina rudimentaria, el estado SALTO se denomina BRANCH.

5.5 Problemas resueltos PROBLEMA 1 Sea un computador básico con las siguientes características: Banco de 4 registros, todos ellos con capacidad de lectura y escritura. Memoria de 29 palabras de 16 bits. Bits de condición N y Z.

186


Y el siguiente repertorio de instrucciones: Instrucción

Operandos

Operaciones que realiza

Acciones sobre N y Z

ADDI

RF1,ⲆNUM,RD

RD p RF1 ! NUM

Modifica N y Z

SUBI

RF1,ⲆNUM,RD

RD p RF1-NUM

Modifica N y Z

NOT

RF,RD

RD p NOT(RF)

Modifica N y Z

ASL

RF,RD

RD p (RF)X2

Modifica N y Z

OR

RF1,RF2,RD

RD p (RF1)OR(RF2)

Modifica N y Z

LOAD

A(RI),RD

RD p MEM(A ! RI)

Modifica N y Z

STORE

RF,A(RI)

MEM(A ! RI) p RF

BEQ

DIR

SI Z%1 p PROX.INST%MEM(DIR)

BLT

DIR

SI N%1 p PROX.INST %MEM(DIR)

BRA

DIR

PROX.INST%MEM(DIR)

BSR

DIR

PROX.INST %MEM(DIR); MEM(R0) p PC

a) Decidir el formato de las instrucciones y, basándose en él, diseñar detalladamente la unidad de proceso. b) Diseñar la unidad aritmético-lógica. Solución: a) Las instrucciones deben incluir el código de operación y los operandos necesarios. Para decidir cuántos bits del formato se utilizan para cada campo analizamos el repertorio de instrucciones. Consideramos que existen 4 tipos de instrucciones: Aritmético-Lógicas: ADDI, SUBI, NOT, ASL y OR LOAD STORE Bifurcación: BEQ, BLT, BRA y BSR Por lo tanto, para diferenciarlas necesitaremos 2 bits en la instrucción que nos indiquen el tipo de instrucción. Por analogía con la máquina rudimentaria establecemos: Tipo de instrucción

Código

LOAD

00

STORE

01

Bifurcación

10

Aritmético-lógicas

11


187

A continuación la instrucción debe proporcionar los operandos necesarios y en el caso de las instrucciones aritmético-lógicas y de bifurcación además tienen que incluir unos bits que diferencien las distintas operaciones o condiciones que se evalúan. Otra característica que nos proporciona el repertorio de instrucciones es que hay que definir seis formatos diferentes de las instrucciones en función de los operandos que estén implicados en cada una de las instrucciones. Así habrá que especificar un formato para ADDI y SUBI, otro para NOT y ASL, otro para la instrucción OR, uno para LOAD, uno para STORE y finalmente uno para las instrucciones de bifurcación. De las características de la máquina sabemos también que: Necesitaremos 2 bits para diferenciar los 4 registros del banco. 9 bits para especificar una dirección de memoria. 3 bits (OP) para especificar la operación de la ALU (tenemos 5 operaciones aritméticológicas; ADDI, SUBI, NOT, ASL y OR). 2 bits (CC) para especificar la condición a evaluar (hay que diferenciar entre BEQ, BLT, BRA y BSR). Dado que no nos indican el tamaño del operando inmediato (ⲆNUM) podremos definirlo con tantos bits como queden libres en las instrucciones correspondientes. Con ello, el formato de las instrucciones quedará de la siguiente forma: Aritmético-lógicas: ADDI y SUBI Código (2 bits)

2 bits

2 bits

7 bits

3 bits

11

RD

RF1

ⲆNUM

OP

Aritmético-lógicas: NOT y ASL Código (2 bits)

2 bits

2 bits

2 bits

5 bits

3 bits

11

RD

XX

RF

XXXXX

OP

Código (2 bits)

2 bits

2 bits

2 bits

5 bits

3 bits

11

RD

RF1

RF2

XXXXX

OP

Aritmético-lógicas: OR

LOAD Código (2 bits)

2 bits

2 bits

1 bits

9 bits

00

RD

RI

X

Dirección

188


STORE Código (2 bits)

2 bits

2 bits

1 bits

9 bits

01

RF

RI

X

Dirección

Bifurcación: BEQ, BLT, BRA y BSR Código (2 bits)

2 bits

2 bits

1 bits

9 bits

10

CC

00

X

Dirección

En el caso de las instrucciones de bifurcación y salto es necesario fijar dos bits a cero para poder reutilizar correctamente los elementos de la máquina rudimentaria en la que para el cálculo de la dirección efectiva se hace una suma con el registro R0 cuyo contenido es siempre cero. b) EL diseño de la unidad aritmético-lógica debe incluir los distintos módulos que pueden intervenir:

PROBLEMA 2 Sea un computador básico que tiene las siguientes características: Un banco de 4 registros. Memoria de 28 palabras # 16 bits. Bits de condición N y Z.


189

Y el siguiente repertorio de instrucciones: Instrucción

Operandos

Operaciones que realiza

Acciones sobre N y Z

ADD

RF1,DIR,RD

RD p RF1 ! MEM(DIR)

Modifica N y Z

SUB

RF1,DIR,RD

RD p RF1 . MEM(DIR)

Modifica N y Z

ADDI

RF1,ⲆNUM,RD

RD p RF1 ! NUM

Modifica N y Z

SUBI

RF1,ⲆNUM,RD

RD p RF1 . NUM

Modifica N y Z

LOAD

A(RI),RD

RD p MEM(A ! RI)

Modifica N y Z

STORE

RF,A(RI)

MEM(A ! RI) p RF

BCC

DIR

Si se cumple la condición CC p Ejecuto el salto

a) Decidir el formato de las instrucciones. b) Responder razonadamente: – ¿Puedo ampliar el número de instrucciones aritmético-lógicas? – ¿Cuántas instrucciones de salto puedo codificar? – ¿Cuál es el rango representable por el número inmediato Ⲇnum? (Todo ello sin modificar en absoluto ninguno de los componentes.) Solución: a) Decidir el formato de las instrucciones. Siguiendo un procedimiento similar al llevado a cabo en el problema 1 podemos establecer que: Necesitaremos 2 bits para diferenciar los 4 registros del banco. 8 bits para especificar una dirección de memoria. 2 bits (OP) para especificar la operación de la ALU (tenemos 4 operaciones aritméticológicas: ADDI, SUBI, ADD y SUB). 2 bits (CC) para especificar la condición a evaluar (hay que evaluar N y Z ya que no especifica nada el enunciado). Dado que no nos indican el tamaño del operando inmediato (ⲆNUM) podremos definirlo con tantos bits como queden libres en las instrucciones correspondientes. Como el tamaño de la instrucción es 16 se puede obtener que podrán destinarse 8 bits a tal efecto (ver formato de ADDI y SUBI). Con ello el formato de las instrucciones quedará de la siguiente forma: Aritmético-lógicas: ADDI y SUBI Código (2 bits)

2 bits

2 bits

8 bits

2 bits

11

RD

RF

ⲆNUM

OP

190


Aritmético-lógicas: ADD y SUB Código (2 bits)

2 bits

2 bits

8 bits

2 bits

11

RD

RF

Dirección

OP

Código (2 bits)

2 bits

2 bits

8 bits

2 bits

00

RD

RI

Dirección

XX

Código (2 bits)

2 bits

2 bits

8 bits

2 bits

01

RF

RI

Dirección

XX

Código (2 bits)

2 bits

2 bits

8 bits

2 bits

10

CC

00

Dirección

XX

LOAD

STORE

Bifurcación: BCC

De nuevo en las instrucciones de salto es necesario fijar dos bits a cero para poder reutilizar correctamente los elementos de la máquina rudimentaria. b) Responder razonadamente: – ¿Puedo ampliar el número de instrucciones aritmético-lógicas? No. No es posible sin modificar el formato de las instrucciones, ya que tanto los bits destinados a especificar el código como los de OP están en uso por las instrucciones especificadas. – ¿Cuántas instrucciones de salto puedo codificar? Podríamos especificar 16 instrucciones diferentes. Aunque hemos destinado 2 bits para los códigos (CC), sería posible utilizar también los 2 bits iniciales de ese formato IR1IR0. Por lo tanto podríamos codificar 22!2 % 16 instrucciones con el código de la instrucción de salto (10). – ¿Cuál es el rango representable por el número inmediato Ⲇnum? Disponemos de 8 bits y dado que suponemos números representados en complemento a 2, el rango será [.27, 27 . 1], o lo que es lo mismo [.128, 127]. PROBLEMA 3 Dibujar la unidad de proceso y la ALU de un computador básico con el repertorio de instrucciones de la máquina rudimentaria expuesta, al que le hemos añadido dos instrucciones aritmético-lógicas: NORI

RF,ⲆNUM,RD

RD p RF(NOR)ⲆNUM

Realiza la NOR

INC

REG;

REG p REG ! 1

(Reg. actúa como fuente y destino)


191

Solución: La unidad de proceso será la de la máquina rudimentaria en el que cambien la unidad aritmético-lógica para incluir las dos operaciones indicadas. La figura incluye la nueva ALU en la estructura general de la MR.

192


PROBLEMA 4 Sea un computador básico con una memoria de 214 palabras de 24 bits, un banco de 16 registros, un registro acumulador (AC) y el repertorio de instrucciones dado: a) Dar un formato de instrucción válido. ADD

RF

AC p RF ! AC

ADDI

RF,ⲆNUM

AC p RF ! ⲆNUM

CD

RF

AC p C2(RF)

CDI

ⲆNUM

AC p C2(ⲆNUM)

LOAD

A(RI),RD

RD p MEM(EA)

STORE

A(RI)

MEM(EA) p AC

BCC

Dirección

Salta SI cierto

b) ¿Cuál es el tamaño del contador de programa? Justifica la respuesta. c) ¿Cuántas instrucciones aritméticas se pueden añadir? Justifica la respuesta. Solución: a) Dar un formato de instrucción válido. Por analogía con la MR vamos a utilizar 2 bits para diferenciar el tipo de operación aunque hay varias soluciones posibles al disponer de 24 bits para codificar la instrucciones, ya que ese es el tamaño de palabra que almacena la memoria y por lo tanto el tamaño máximo que puede tomar el IR. Aritmético-lógicas: ADDI, CDI 2 bits

4 bits

16 bits

2 bits

Cód

RF

ⲆNUM

OP

Aritmético-lógicas: ADD, CD 2 bits

4 bits

16 bits

2 bits

Cód

RF

XXXX XXXX XXXX XXXX

OP

LOAD 2 bits

4 bits

4 bits

14 bits

Cód

RF

RI

Dirección

2 bits

4 bits

16 bits

2 bits

Cód

RD

RI

Dirección

2 bits

4 bits

16 bits

2 bits

Cód

COND

0000

Dirección

STORE

BCC


193

b) ¿Cuál es el tamaño del contador de programa? El tamaño del contador de programa viene determinado por la memoria y por lo tanto será de 14 bits para poder acceder a todas las posiciones de la misma. c) ¿Cuántas instrucciones aritméticas se pueden añadir? Con el diseño que se ha propuesto del formato de las instrucciones no se podrían añadir instrucciones aritmético-lógicas, ahora bien se podría modificar el formato de las instrucciones aritmético-lógicas incrementando el tamaño del campo OP todo lo que nos permita el tamaño del operando inmediato. Suponiendo un tamaño de 5 bits para el campo inmediato podríamos definir de nuevo los formatos como: Aritmético-lógicas con inmediato: 2 bits

4 bits

16 bits

2 bits

Cód

RF

ⲆNUM

OP

Aritmético-lógicas sin operando inmediato: 2 bits

4 bits

16 bits

2 bits

Cód

RF

XXXXX

OP

Este nuevo diseño permitiría definir hasta 213 instrucciones aritmético-lógicas. PROBLEMA 5 Sea un computador básico con una memoria de 26 palabras de 16 bits, un banco de 16 registros, un registro acumulador (AC) y el repertorio de instrucciones dado: a) Dar un formato de instrucción válido. ADD

RF

AC p RF ! AC

ADDI

RF,ⲆNUM

AC p RF ! ⲆNUM

CD

RF

AC p C2(RF)

CDI

ⲆNUM

AC p C2(ⲆNUM)

LOAD

A(RI),RD

RD p MEM(EA)

STORE

A(RI)

MEM(EA) p AC

BCC

Dirección

Salta SI cierto

b) Diseña la unidad de proceso de dicho computador indicando el tamaño de los buses y las señales de control. ¡¡ Load no modifica los bits de condición!! c) ¿En cuántas fases se ejecutaría la instrucción LOAD de este computador? ¿Qué señales de control deberían activarse en cada fase? La respuesta debe ser coherente con el diseño del apartado anterior.

194


Solución: a) Dar un formato de instrucción válido. El repertorio de instrucciones es el mismo que el del problema 4, por lo tanto sólo debemos adaptar el formato a los tamaños de memoria, palabra y banco de registro indicados: Aritmético-lógicas: ADDI, CDI 2 bits IR15-14

4 bits IR13-10

8 bits IR9-2

2 bits IR1-10

Cód

RF

ⲆNUM

OP

Aritmético-lógicas: ADD, CD 2 bits IR15-14

4 bits IR13-10

8 bits IR9-2

2 bits IR1-10

Cód

RF

XXXX XXXX

OP

LOAD 2 bits IR15-14

4 bits IR13-10

4 bits IR9-6

6 bits IR5-0

Cód

RF

RI

Dirección

2 bits IR15-14

4 bits IR13-10

4 bits IR9-6

6 bits IR5-0

Cód

RD

RI

Dirección

2 bits IR15-14

4 bits IR13-10

4 bits IR9-6

6 bits IR5-0

Cód

COND

0000

Diección

STORE

BCC

b) Diseña la unidad de proceso de dicho computador indicando el tamaño de los buses y las señales de control. La modificación principal se debe realizar cerca de la ALU, debemos sustituir (o reutilizar) el registro auxiliar por un registro acumulador y añadir un multiplexor para seleccionar los operandos también en la entrada del operando A. En cuanto al tamaño de los buses, se verán modificados todos aquellos que tenga que ver con las direcciones que pasarán de 8 a 6 bits. Los bits de selección de los registros también cambiarán de 3 a 4 bits para poder acceder a los 16 registros, que es el nuevo tamaño del banco de registros.


195

Por otra parte, dado que ahora sólo tenemos dos opciones de acceso al banco de registros para lectura, el multiplexor de selección de lectura sólo tendrá dos entradas activas. Podríamos sustituirlo de igual forma por un multiplexor de 2 a 1, pero de esta forma no deberemos modificar el diseño inicial. Las señales de control de la unidad aritmético-lógica también podrían modificarse o simplemente reutilizar las conexiones y cambiar las señales de control para cada estado.

196


c)

¿En cuántas fases se ejecutaría la instrucción LOAD de este computador? ¿Qué señales de control deberían activarse en cada fase? La respuesta debe ser coherente con el diseño del apartado anterior. La instrucción LOAD debe realizar los siguientes pasos: 1.

FETCH: Carga de la instrucción en el registro IR y PC p PC ! 1.

2.

DECO: Decodificación de la instrucción.

3.

ADDR: Calcular la dirección efectiva.

4.

LOAD: Acceder a la posición de memoria calculada en el paso anterior y almacenar su contenido en el registro destino. Las señales de control necesarias son: CRF: Control del multiplexor de selección del registro fuente. LPC: Señal de carga del PC. LIR: Señal de carga del IR. LR@: Señal de carga del R@. R/W: Señal de lectura/escritura de la memoria. E: Señal de escritura en el banco de registros. LN: Carga del registro de estado N. LZ: Carga del registro de estado Z. ALU: Operación de la ALU. CMUX: Control del multiplexor de entrada a la ALU. CMAC: Control del multiplexor al que se conecta el registro acumulador. C@: Control del multiplexor de selección de direcciones. LAC: Carga del registro acumulador (AC).

Fase

CRF LPC

LIR LR@ R/W

E

LN

LZ

ALU CMUX CMAC C@ LAC

FETCH

X

1

1

0

0

0

0

0

X

X

X

0

0

DECO

1

0

0

0

0

0

0

0

X

X

X

0

0

ADDR

1

0

0

1

0

0

0

0

X

X

X

X

0

LOAD

X

0

0

0

0

1

0

0

0

1

X

1

0

PROBLEMA 6 a) Explicar breve pero detalladamente la función de los siguientes elementos de la unidad de proceso de la máquina rudimentaria. – El registro de instrucciones (IR). – La unidad aritmético-lógica (ALU).


197

b) Completar el siguiente gráfico «correspondiente» a la lógica necesaria para realizar el cálculo de direcciones; explicando por qué se añaden los nuevos elementos.

Solución: a) Explicar breve pero detalladamente la función de los siguientes elementos de la unidad de proceso de la máquina rudimentaria. – El registro de instrucciones (IR). El registro de instrucciones almacena la instrucción que se está ejecutando en el procesador. El dato procede de la memoria y por lo tanto tendrá el mismo ancho que la palabra de memoria. El registro de instrucciones se carga durante la fase de FETCH y no debe modificarse durante ninguna de las fases que pertenecen a la misma instrucción, ya que en el código de instrucción se incluyen señales de selección que afectarán a la ejecución de la instrucción en esas fases. – La unidad aritmético-lógica (ALU). La unidad aritmético-lógica se encarga de realizar las operaciones aritmético-lógicas y modifica los bits N y Z que sirven para tomar las decisiones en las instrucciones de bifurcación. b) Completar el siguiente gráfico «correspondiente» a la lógica necesaria para realizar el cálculo de direcciones de 12 bits; explicando por qué se añaden los nuevos elementos. La lógica necesaria para el cálculo de direcciones es la siguiente:

198


Al esquema del enunciado se han añadido varios elementos. En primer lugar, se ha incorporado el sumador !1 que se encarga de hacer el autoincremento de la dirección. Recordemos que la máquina con la que estamos trabajando supone secuenciamiento implícito que significa que la siguiente instrucción a ejecutar es la siguiente instrucción en memoria, salvo que una condición de salto indique lo contrario. Para calcular la dirección efectiva utilizamos un sumador que la obtiene sumando el contenido del registro índice con la dirección base contenida en la instrucción. PROBLEMA 7 Queremos añadir dos nuevas instrucciones aritmético-lógicas: – ANDI Rf,Ⲇnum,Rd – ORI Rf,Ⲇnum,Rd a) Dar un formato a dichas instrucciones. b) Rediseñar la ALU y, si aparecen nuevas señales, diseñar los sistemas que las crean. Solución: a) Dar un formato a dichas instrucciones. Para codificar las instrucciones debemos aprovechar los dos códigos que quedaron libres en el diseño del repertorio de la máquina rudimentaria. Además como los dos códigos de los que disponemos se corresponden con operaciones de inmediato en la ALU podremos codificarlos sin problemas de la siguiente forma: ANDI: Código (2 bits) IR15-14

3 bits IR13-11

3 bits IR10-8

5 bits IR7-3

3 bits IR2-0

11

RD

RF1

ⲆNUM

OP 010

Código (2 bits) IR15-14

3 bits IR13-11

3 bits IR10-8

5 bits IR7-3

3 bits IR2-0

11

RD

RF1

ⲆNUM

OP 011

ORI:


199

b) Rediseñar la ALU y, si aparecen nuevas señales, diseñar los sistemas que las crean.

Reutilizando las señales del código de operación (OP) no es necesario definir nuevas señales. La señal ALU valdrá 0 para las instrucciones de LOAD y 1 para las instrucciones aritmético-lógicas. PROBLEMA 8 Sea un computador básico con un banco de 32 registros, un bus de datos de 16 bits y el repertorio de instrucciones dado a continuación: ADD

RF,RD

RD p RF ! RD

SUB

RF, RD

RD p RF . RD

ADDI

ⲆNUM, RD

RD p RD ! ⲆNUM

SUBI

ⲆNUM, RD

RD p RD-ⲆNUM

LOAD

A(RI),RD

RD p MEM(A ! RI)

STORE

A(RI)

MEM(A ! RI) p RF

BCC

Dirección

Salta SI cierto

200


Contesta las siguientes preguntas: a) Dar un formato de instrucción válido. b) ¿Cuál es el rango del número inmediato (Ⲇnum) si este se codifica en notación C2? c)

¿Cuál es el tamaño del contador de programa? Justifica la respuesta

d) ¿Cuántas instrucciones de salto se podrían llegar a codificar? e)

¿Cuántas instrucciones aritméticas con operandos en registro se pueden añadir? Justifica la respuesta.

f)

Diseñar la unidad de proceso indicando el tamaño de las líneas y las señales de control necesarias sabiendo que sólo las instrucciones aritméticas modifican N y Z.

g) Indicar el valor que deben tomar las señales de control, descritas en el apartado anterior, en la fase «Lectura del primer operando». Solución: a) Dar un formato de instrucción válido. De las características de la máquina sabemos también que: Necesitaremos 5 bits para diferenciar los 32 registros del banco. No nos índican el tamaño de la memoria por lo que habrá que asignarles tantos bits como podamos en las instrucciones de LOAD y STORE. 2 bits (OP) para especificar la operación de la ALU (tenemos 4 operaciones aritméticológicas; ADDI, SUBI, ADD y SUB). 3 bits (CC) para especificar la condición a evaluar (si no nos indican lo contrario utilizamos la configuración base de la MR). Dado que no nos indican el tamaño del operando inmediato (ⲆNUM) podremos definirlo con tantos bits como queden libres en las instrucciones correspondientes. Con ello el formato de las instrucciones quedará de la siguiente forma: ADDI Código IR15-14

5 bits IR13-9

7 bits IR8-2

2 bits IR1-0

11

RD

ⲆNUM

OP % 00

Código IR15-14

5 bits IR13-9

7 bits IR8-2

2 bits IR1-0

11

RD

ⲆNUM

OP % 10

SUBI


201

ADD Código IR15-14

5 bits IR13-9

5 bits IR8-4

2 bits IR3-2

2 bits IR1-0

11

RD

RF

XX

OP % 01

Código IR15-14

5 bits IR13-9

5 bits IR8-4

2 bits IR3-2

2 bits IR1-0

11

RD

RF

XX

OP % 11

SUB

LOAD Código IR15-14

5 bits IR13-9

5 bits IR8-4

4 bits IR3-0

01

RF

RI

Dirección

Código IR15-14

5 bits IR13-9

5 bits IR8-4

4 bits IR3-0

11

RF

RI

Dirección

Código IR15-14

5 bits IR13-9

5 bits IR8-4

4 bits IR3-0

11

CC

00000

Dirección

STORE

Bifurcación:

b) ¿Cuál es el rango del número inmediato (Ⲇnum) si éste se codifica en notación C2? Dado que disponemos de 7 bits, el rango será [.26, 26 . 1] % [.64, 63]. c)

¿Cuál es el tamaño del contador de programa? Este es uno de los grandes inconvenientes que presentaría este computador, ya que la memoria que podemos direccionar se ha quedado reducida a 24 posiciones, ya que esos son los bits disponibles en el formato de las instrucciones LOAD y STORE. Como resulta evidente, este diseño sería conveniente modificarlo y conseguir tener acceso a más posiciones de memoria, ya que de lo contrario no podríamos codificar prácticamente ningún programa. El PC tiene un tamaño de 4 bits.

202


d) ¿Cuántas instrucciones de salto se podrían llegar a codificar? Dado que en la instrucción de salto se han destinado 5 bits para el código de condición, podríamos tener 25 instrucciones diferentes. e)

¿Cuántas instrucciones aritméticas con operandos en registro se pueden añadir? Justifica la respuesta. Al asignar los códigos de operación hemos utilizado IR0 para indicar si la operación utiliza un inmediato (IR0 % 0) o un registro (IR0 % 1). El segundo bit IR1 especifica el tipo de operación. Para las operaciones con registro disponemos de dos bits libres (IR3-2), por lo que los códigos disponibles para nuevas instrucciones serían los 6 recogidos en la tabla siguiente en la que ya se han ocupado los códigos de operación asignados anteriormente a la suma y a la resta entre registros:

f)

Instrucción

IR3-1

IR0

ADD

000

1

SUB

001

1

Nueva

010

1

Nueva

011

1

Nueva

100

1

Nueva

101

1

Nueva

110

1

Nueva

111

1

Diseñar la unidad de proceso indicando el tamaño de las líneas y las señales de control necesarias sabiendo que sólo las instrucciones aritméticas modifican N y Z. Las principales modificaciones son las siguientes: El multiplexor de selección de lectura será de dos entradas para discernir entre RD y RI/RF. La instrucción de LOAD no pasa por la ALU, puesto que no modifica los bits N y Z puede ir directamente a la entrada del banco de registros, donde se utiliza la señal ALU para cargar el dato de la memoria (ALU % 0) o almacenar el resultado de la ALU (ALU % 1). La entrada del segundo operando a la unidad aritmético-lógica se selecciona ahora con un solo bit indicado por IR0, que como se ha explicado nos indica si el operando es inmediato o procede de un registro. La unidad aritmético-lógica sólo necesita un bit de control para indicar si es una operación de suma o de resta (IR1). El tamaño de los buses de direcciones se ha reducido a 4 bits. El tamaño de los buses de selección de registros se ha aumentado a 5 bits, tanto para lectura como para escritura.


203

g) Indicar el valor que deben tomar las señales de control, descritas en el apartado anterior, en la fase «Lectura del primer operando». Para hacer la lectura del primer operando debemos cargarlo en el registro auxiliar, por lo tanto la señal de carga de ese registro debe estar activa LRAUX % 1; CRF debe ser 0 para seleccionar el registro RD, ya que es el que hemos considerado como primer ope-

204


rando en el diseño (al poner el inmediato en la otra entrada). El resto de señales de carga las dejaremos a cero para evitar escritura de datos erróneos, al igual que las señales de escritura de memoria y del banco de registros. El resto de señales de selección de los multiplexores no son transcendentes en esta fase y por tanto no es necesario asignarles un valor concreto. PROBLEMA 9 Diseñar detalladamente la ALU de una máquina similar a la MR con el siguiente repertorio de instrucciones aritmético-lógicas: {ADD, SUB, AND, XOR, NOT, ASR, ASL, ADDI, SUBI, ANDI} Todas ellas, junto con LOAD, modifican N y Z. Dar además un código de operación para cada una. ¿Cuántas instrucciones aritmético-lógicas más se podrían añadir?¿Por qué? Solución: La forma más sencilla es seguir el esquema de conexión de otros ejercicios:

Para que funcione correctamente debemos definir los códigos (COD), que controlan el multiplexor de 8 a 1, de la siguiente forma:


Instrucción

ALU

COD

ADD

0

000

SUB

0

001

AND

0

010

XOR

0

011

NOT

0

100

ASR

0

101

ASL

0

110

ADDI

1

000

SUBI

1

001

ANDI

1

010

205

La elección entre el operando que proporciona el registro y el operando inmediato se hará fuera de la unidad aritmético-lógica y se controlará mediante un bit adicional (ALU) en el formato de las instrucciones. El número total de instrucciones que se pueden codificar son 16 y para ello utilizaríamos las posiciones que han quedado libres en la tabla anterior. Es decir: Instrucción

ALU

COD

Libre

0

111

Libre

1

011

Libre

1

100

Libre

1

101

Libre

1

110

Libre

1

111

PROBLEMA 10 Dibujar detalladamente sólo los elementos de la unidad de proceso involucrados en la fase STORE (la última de la instrucción STORE) de una máquina similar a la MR pero con una memoria de 1K % 210 palabras y un banco de 16 registros. Además responder razonadamente a las siguientes preguntas: ¿Cuál será el tamaño de IR? ¿Por qué? ¿Cuál será el tamaño de PC? ¿Por qué?

206


Solución: Lo primero que hay que estudiar es el formato de las instrucciones que se debe utilizar y en su caso comprobar qué anchos de los buses y tamaño de los registros se deben modificar. Para ello hay que tener en cuenta que para direccionar una memoria de 1 K palabras necesitamos 10 bits en los buses de dirección y para acceder a los 16 registros necesitamos 4 bits en los buses de selección de lectura y de escritura, por lo que estos valores deben modificarse en el formato de las instrucciones original: LOAD Código (2 bits)

4 bits

4 bits

10 bits

00

RD

RI

Dirección

Código (2 bits)

4 bits

4 bits

10 bits

01

RF

RI

Dirección

Código (2 bits)

4 bits

4 bits

10 bits

10

CC

0000

Dirección

STORE

Bifurcación: BCC

Aritmético-lógicas: ADDI y SUBI Código (2 bits)

4 bits

4 bits

7 bits

3 bits

11

RD

RF1

ⲆNUM

OP

Aritmético-lógicas: ADD y SUB Código (2 bits)

4 bits

4 bits

4 bits

3 bits

3 bits

11

RD

RF1

RF2

XXX

OP

El proceso de diseño del formato debe comenzar por la instrucción que más bits necesite para su codificación, en este caso son las instrucciones de LOAD y STORE. Eso nos fijará el tamaño de palabra y nos permitirá determinar el tamaño máximo del operando inmediato en las instrucciones que lo utilicen. Para codificar las instrucciones de LOAD y STORE son necesarios 20 bits, por lo que el inmediato ⲆNUM podrá utilizar hasta 7 bits. Con estos datos ya podemos contestar a las dos cuestiones planteadas. El registro de instrucciones IR debe tener el mismo tamaño que la palabra para poder obtener la instrucción completa en las fases definidas por la unidad de control, por lo tanto 20 bits. Para poder acceder a toda la memoria necesitamos 10 bits y dado que las instrucciones se pueden encontrar en cualquier dirección de la misma el registro contador de programa (PC) debe tener un tamaño de 10 bits.


207

Vayamos ahora con el diseño. Bastará con modificar los elementos que nos solicitan, teniendo en cuenta los tamaños de los buses y registros y modificando los valores de selección que provienen del IR. Así, las nuevas entradas de selección del multiplexor selector de registro de lectura serán ahora IR17-14, IR13-10 e IR9-6. Aunque no afecta a la fase solicitada en el problema, también cambiaría la señal de selección de escritura en el registro SE, ahora debe leer los bits IR17-14 del registro de instrucciones, tal y como se indica en la figura.

PROBLEMA 11 Para el formato de instrucciones obtenido en el problema 9, indicar qué significado tienen para la máquina los siguientes datos almacenados como instrucciones en la memoria: 148A8h;

4A001h;

CA441h;

CC4C5h

Solución: Dado que la máquina interpreta el código según el formato de bits obtenido, lo que tenemos que hacer es traducir los números en hexadecimal a binario, comprobar los dos primeros bits que nos indicarán el tipo de instrucción y a partir de ahí deducir el significado de cada código: El primer dato es 148A8h % (0001 0100 1000 1010 1000)2. Como vemos los dos bits más significativos son 00, por lo que se trata de una instrucción de tipo LOAD, si escribimos esto

208


bits en el formato obtenido para la instrucción en el problema anterior obtendremos cómo lo interpretará nuestra máquina: LOAD Código (2 bits)

4 bits

4 bits

10 bits

00

RD

RI

Dirección

00

0101

0010

(0010101000)2 % (168)10

La instrucción es por tanto: LOAD DIRECCIÓN(RI), RD % LOAD 168(R2),R5. Siguiendo el mismo procedimiento para el resto de datos obtenemos las instrucciones solicitadas: 4A001h % (0100 1010 0000 0000 0001)2 r STORE RF, DIRECCION(RI) Código (2 bits)

4 bits

4 bits

10 bits

01

RF

RI

Dirección

01

0010

1000

(0000000001)2 % (1)10

La instrucción es por tanto: STORE R2,1(R8). CA441h % (1100 1010 0100 0100 0001)2 r ADDI RF1,ⲆNUM,RD Código (2 bits)

4 bits

4 bits

7 bits

3 bits

11

RD

RF1

ⲆNUM

OP

11

0010

1001

0001000

001

La instrucción es por tanto: ADDI R9, Ⲇ, R2. CC4C5h % (1100 1100 0100 1100 0101)2 r SUB RF1,RF2,RD Código (2 bits)

4 bits

4 bits

4 bits

3 bits

3 bits

11

RD

RF1

RF2

XXX

OP

11

0011

0001

0011

000

101

La instrucción es por tanto: SUB R1, R3, R3. Obsérvese que para las instrucciones aritmético-lógicas (ADDI y SUB), además de los dos bits más significativos, debemos chequear el código de operación para saber cuál es la instrucción que está codificada. Estos bits se encuentran en las posiciones menos significativas de la instrucción IR2-0.


209

PROBLEMA 12 Para el formato de instrucciones obtenido en el problema 9, escribir la codificación en hexadecimal equivalente de las siguientes instrucciones: a) BG AA b) SUB R1,R3,R5 c)

STORE R2,EE(R1)

Solución: a) BG AA El proceso para obtener las codificaciones es el inverso al anterior. Bastará con codificar las instrucciones siguiendo el formato obtenido en el problema 9: Bifurcación: BCC Código (2 bits)

4 bits

4 bits

10 bits

10

CC

0000

Dirección

En este caso desconocemos cuál es el código de condición (CC). Dado que el enunciado original nos indicaba que partíamos de la máquina descrita en la introducción teórica, supondremos los mismos valores pero teniendo en cuenta que los CC ahora tienen 4 bits para adecuarse al formato definido: Instrucción en lenguaje ensamblador

CC

Condición a evaluar

Tipo de salto

BR dirección

0000

1

Incondicional

BEQ dirección

0001

Z

Salto SI resultado % 0

BL dirección

0010

N

Salto SI resultado a 0

BLE dirección

0011

N(OR)Z

Salto SI resultado m 0

BNE dirección

0101

NOT(Z)

Salto SI resultado Ç 0

BGE dirección

0110

NOT(N)

Salto SI resultado n 0

BG dirección

0111

NOT(N (OR) Z)

Salto SI resultado b 0

La instrucción BG AA se codificará por lo tanto como (1001 1100 0000 1010 1010)2 % 9C0AAh Código (2 bits)

4 bits

4 bits

10 bits

10

CC

0000

Dirección

10

0111

0000

(0010101010)2 % AAh

210


b) SUB R1,R3,R5 Código (2 bits)

4 bits

4 bits

4 bits

3 bits

3 bits

11

RD

RF1

RF2

XXX

OP

11

R5

R1

R3

000

001

11

0101

0001

0011

000

001

SUB R1,R3,R5 se codificará como (1101 0100 0100 1100 0101)2 % D44C5h c) STORE R2,EE(R1) Código (2 bits)

4 bits

4 bits

10 bits

01 01 01

RF R2 0010

RI R1 0001

Dirección EE 0011101110

STORE R2,EE(R1) se codificará como (0100 1000 0100 1110 1110)2 % 484EEh PROBLEMA 13 Se añaden dos instrucciones aritmetico-lógicas a la MR estudiada en el curso: – XORI

Rf,Ⲇnum,Rd

– XOR

Rf1,Rf2 ,Rd

a) Dar una codificación para las nuevas instrucciones. b) ¿Cuál es ahora el rango de números representables en las instrucciones aritméticas con operando inmediato? Razona la respuesta. c)

¿Cuál es ahora el tamaño del banco de registros? Razona la respuesta.

d) ¿Cuál es ahora el tamaño del registro de direcciones R@? Razona la respuesta. Propuestos e) ¿Cuánto tiempo tardaría en ejecutarse la fase fetch? Justifica la respuesta utilizando los siguientes tiempos de respuesta: Multiplexor 10 ns ALU 80 ns Sumador 40 ns Leer / escribir en banco 40 ns Evaluador de condición 30 ns Leer / escribir en memoria 100 ns f)

Diseña detalladamente la UP de dicha máquina teniendo en cuenta las nuevas instrucciones.

Solución: a) Dar una codificación para las nuevas instrucciones. Para codificar las dos nuevas instrucciones debemos utilizar los códigos OP que quedaron disponibles en el diseño original, que eran 010 y 011. Una posible solución es:


211

XORI RF, ⲆNUM, RD Código (2 bits)

3 bits

3 bits

5 bits

3 bits

11

RD

RF

ⲆNUM

010

XOR RF1,RF2,RD Código (2 bits)

3 bits

3 bits

3 bits

2 bits

3 bits

11

RD

RF1

RF2

XXX

011

Hay que tener en cuenta que esta modificación añade complejidad al diseño de la unidad de proceso, puesto que anteriormente los códigos OP que comenzaban por cero indicaban que se trataba de una operación con un operando inmediato (000 para ADDI y 001 para SUBI9, mientras que los que comenzaban por uno (000 a 111) se utilizaban para operaciones cuyos dos operandos eran registros. Esto ya no es así porque la instrucción XOR tiene asignado OP % 011 y utiliza dos operandos almacenados en el banco de registro. La solución es sencilla, únicamente hay que modificar la señal de control de acceso del multiplexor de entrada de la ALU, haciendo que se seleccionen correctamente los operandos necesarios para cada instrucción. Las entradas correspondientes a la ALU quedarán ahora como indica la figura.

212


La señales SEL1SEL0 deben implementar la siguiente lógica: Instrucción

Tipo (IR15IR14)

OP % IR2IR1IR0

SEL1SEL0

Operando 2

ADDI

11

000

00

Inmediato

SUBI

11

001

00

Inmediato

XORI

11

010

00

Inmediato

XOR

11

011

10

Registro

ADD

11

100

10

Registro

ADDI

11

101

10

Registro

ASR

11

110

10

Registro

AND

11

111

10

Registro

LOAD

00

XXX

01

Memoria

STORE

01

XXX

10

Memoria

Y los valores de las señales ALU2ALU1ALU0 deben seleccionar la operación correcta tras el rediseño de la ALU para incluir la operación XOR. b) ¿Cuál es ahora el rango de números representables en las instrucciones aritméticas con operando inmediato? Razona la respuesta. No se modifica el tamaño del operando inmediato, por lo que seguimos teniendo 5 bits para representar y el rango es [.16, 15]. c)

¿Cuál es ahora el tamaño del banco de registros? 8 registros, no se modifica.

d) ¿Cuál es ahora el tamaño del registro de direcciones R@? No se modifica el tamaño de las direcciones ni de la memoria, por lo que seguirá siendo de 8 bits. PROBLEMA 14 Para un procesador como el definido en la parte teórica y suponiendo los siguientes tiempos de respuesta: Multiplexor 10 ns ALU 80 ns Sumador 40 ns Leer/escribir en banco de registros 40 ns Evaluador de condición 30 ns Leer / escribir en memoria 100 ns ¿Cuánto tiempo tardaría en ejecutarse la fase fetch? Justifica la respuesta utilizando los siguientes tiempos de respuesta:


213

Solución: Durante la fase de fetch debemos realizar las siguientes operaciones: PC p PC ! 1 y cargar la instrucción en el registro IR. Estas dos operaciones se realizan simultáneamente, por lo que para calcular el retardo t de esta etapa debemos calcular cuánto tarda cada una de ellas y ver cuál es la operación con mayor retardo: tPCpPC!1 % tMULTIPLEXOR ! tSUMADOR % 50 ns

tIRpMEM[PC] % tMULTIPLEXOR ! tMEMORIA % 110 ns

Por lo tanto el retardo de esta estapa viene marcado por la carga del registro de instrucciones y será 110 ns.

214


PROBLEMA 15 Sea una máquina similar a la MR con las siguientes modificaciones: Un banco de 16 registros de 32 bits. Dos instrucciones lógicas nuevas: – ANDI Rf,Ⲇnum,Rd – ORI Rf,Ⲇnum,Rd a) Propón un formato de instrucción que optimice los bits. b) ¿Cuál es ahora el rango de números representables en las instrucciones aritméticas con operando inmediato? Razona la respuesta. c)

¿Cuál es ahora el tamaño máximo que puede tener la memoria? Razona la respuesta.

d) ¿Cuál es ahora el tamaño del contador de programa? Razona la respuesta. Solución: a) Propón un formato de instrucción que optimice los bits. Para codificar las nuevas instrucciones debemos aprovechar los dos códigos que quedaron libres en el diseño del repertorio de la máquina rudimentaria. Además, como los dos códigos de los que disponemos se corresponden con operaciones de inmediato en la ALU, podremos codificarlos sin problemas de la siguiente forma: ANDI: Código IR31-30

4 bits IR29-26

4 bits IR25-22

19 bits IR21-3

3 bits IR2-0

11

RD

RF1

ⲆNUM

OP 010

Código IR31-30

4 bits IR29-26

4 bits IR25-22

19 bits IR21-3

3 bits IR2-0

11

RD

RF1

ⲆNUM

OP 011

ORI:

El resto de instrucciones quedará Aritmético-lógicas: ADDI y SUBI Código IR31-30

4 bits IR29-26

4 bits IR25-22

19 bits IR21-3

3 bits IR2-0

11

RD

RF1

ⲆNUM

OP


215

Aritmético-lógicas: ADD, SUB, AND y ASL Código IR31-30

4 bits IR29-26

4 bits IR25-22

4 bits IR21-18

15 bits IR17-3

3 bits IR2-0

11

RD

RF1

RF2

XXXXX

OP

Código IR31-30

4 bits IR29-26

4 bits IR25-22

14 bits IR21-8

8 bits IR7-0

00

RD

RI

XXXXXXXXXXXXXX

Dirección

Código IR31-30

4 bits IR29-26

4 bits IR25-22

14 bits IR21-8

8 bits IR7-0

00

RF

RI

XXXXXXXXXXXXXX

Dirección

LOAD

STORE

Bifurcación: BEQ, BLT, BRA y BSR Código IR31-30

4 bits IR29-26

4 bits IR25-22

14 bits IR21-8

8 bits IR7-0

00

CC

0000

XXXXXXXXXXXXXX

Dirección

b) ¿Cuál es ahora el rango de números representables en las instrucciones aritméticas con operando inmediato? El rango de números será el que nos indica el tamaño del operando inmediato en el formato propuesto (19 bits). Suponiendo igualmente representación en complemento a 2: [.218, 218 . 1]. c)

¿Cuál es ahora el tamaño máximo que puede tener la memoria? En el formato propuesto, la memoria sólo puede tener 256 posiciones que son las que se pueden acceder con los 8 bits asignados a la dirección. Ahora bien en todos los formatos de las instrucciones que implican una dirección, hay otros 14 bits que no están en uso y que podrían transformar ese campo en un campo de 22 bits, para permitir un acceso a una memoria de 4 M % 222 palabras quedando entonces el formato: LOAD Código IR31-30

4 bits IR29-26

4 bits IR25-22

22 bits IR21-0

00

RD

RI

Dirección

216


STORE Código IR31-30

4 bits IR29-26

4 bits IR25-22

22 bits IR21-0

00

RF

RI

Dirección

Bifurcación: BEQ, BLT, BRA y BSR Código IR31-30

4 bits IR29-26

4 bits IR25-22

22 bits IR21-0

00

CC

0000

Dirección

d) ¿Cuál es ahora el tamaño del contador de programa? Si ampliamos la memoria como se ha expuesto en el apartado c), el tamaño del contador de programa debe ser de 22 bits. PROBLEMA 16 Dada una máquina que posea el mismo juego de instrucciones que la máquina rudimentaria y donde se desean realizar las siguientes modificaciones: Trabaje con números en complemento a 2 de 32 bits. Tenga 16 registros de propósito general (del tamaño más conveniente). Tenga una memoria de 64 Kpalabras en vez de 256 palabras. a) ¿Qué modificaciones habría que hacer en la ALU y los buses internos? b) ¿Y en el registro de instrucciones (IR) y anchura de la memoria? c)

¿Cuál deberá ser la anchura (tamaño de palabra) del banco de registros y registros internos de la UP?

d) ¿Se verán afectadas las unidades funcionales para el cálculo de las direcciones de salto de la UP? e)

Considerando la nueva arquitectura, ¿cómo se puede aumentar el número de instrucciones aritméticas hasta 32?

f)

¿Tendría alguna repercusión en las instrucciones de salto de la máquina rudimentaria?

g) Suponiendo que el banco de registros de la UP permitiera leer dos registros del banco de registros simultáneamente, ¿qué estados del diagrama de Moore de la unidad de control simplificada habría que modificar y/o eliminar? Solución: a) ¿Qué modificaciones habría que hacer en la ALU y los buses internos? La ALU debe ser modificada para que todos sus circuitos internos trabajen con números de 32 bits en vez de 16, los buses internos deben ser de las siguientes anchuras: Banco registros – Memoria de 32 bits. Memoria – Registro de instrucciones (IR) de 32 bits.


217

Memoria – ALU de 32 bits. Salida multiplexor SELDIR – M@ de 16 bits. b) ¿Y en el registro de instrucciones (IR) y anchura de la memoria? El registro de instrucciones (IR) debe ser de 32 bits, al igual que la memoria, para poder almacenar números en complemento a 2 de 32 bits. c)

¿Cuál deberá ser la anchura (tamaño de palabra) del banco de registros y registros internos de la UP? El banco de registros debe tener 16 posiciones de 32 bits cada una. Los registros deben ser de los siguientes tamaños en bits: Contador de programa (PC) de 16 bits. R@ de 16 bits. RA de 32 bits.

d) ¿Se verán afectadas las unidades funcionales para el cálculo de las direcciones de salto de la UP? La lógica para el cálculo de direcciones sólo es el sumador que existe entre el banco de registros e IR y el registro R@, que debe ser de 16 bits en vez de 8 como en la máquina rudimentaria inicial. e)

Considerando la nueva arquitectura, ¿cómo se puede aumentar el número de instrucciones aritméticas hasta 32? Para poder tener 32 operaciones aritméticas harían falta 5 bits en vez de 3 bits para el campo de operación (CO), en las posiciones IR2IR1IR0. Es decir, el formato de instrucciones para las operaciones aritméticas quedaría en 32 bits, para la nueva máquina rudimentaria propuesta en este ejercicio, de la forma: Aritmético-lógicas entre registros Código IR31-30

4 bits IR29-26

4 bits IR25-22

4 bits IR21-18

13 bits IR17-5

5 bits IR4-0

11

RD

RF1

RF2

XXXXX

OP

Aritmético-Lógicas registro-inmediato

f)

Código IR31-30

4 bits IR29-26

4 bits IR25-22

17 bits IR21-5

5 bits IR4-0

11

RD

RF1

ⲆNUM

OP

¿Tendría alguna repercusión en las instrucciones de salto de la máquina rudimentaria? Esta modificación no tendría ninguna repercusión en el formato de las instrucciones de salto de la máquina rudimentaria.

g) Suponiendo que el banco de registros de la UP permitiera leer dos registros del banco de registros simultáneamente, ¿qué estados del diagrama de Moore de la unidad de control simplificada habría que modificar y/o eliminar?

218


Se podría eliminar el estado DECO del diagrama de Moore ya que la activación de la señal LRAUX no sería necesaria (dicho registro desaparecería de la unidad de proceso al poder leerse los dos registros fuente en el mismo ciclo) y la otra señal de control generada en dicho estado (LR@) es compatible con los estados que aparecen a continuación en el diagrama simplificado, por lo que se activaría en dichos estados directamente. Como resultado, todas las operaciones reducirían en uno el número total de ciclos que tardan en ejecutarse. Por ejemplo, las operaciones aritmético-lógicas pasarían a tardar 2 ciclos (FETCH ! ARIT) en vez de 3, de manera análoga a como sucedería con el resto de tipos de instrucciones. PROBLEMA 17 Se desea añadir a la máquina rudimentaria básica dos nuevas instrucciones: XOR Rf1, Rf2, Rd: Calcula la «O-exclusiva» bit a bit de dos operandos almacenados en registros y deposita el resultado en un registro destino. NOT Rf, Rd: Realiza la negación de todos los bits de un operando y deposita el resultado en un registro destino. a) Define un formato válido para las instrucciones aritmético-lógicas de la nueva máquina, especificando todos los campos de las instrucciones y su significado, sin modificar la longitud total de las instrucciones, ni la longitud de los operandos inmediatos. b) Diseña la nueva ALU teniendo en cuenta las decisiones del apartado anterior. Además, si la unidad de control se viera afectada por el diseño realizado se deben indicar los cambios que son necesarios en sus diagramas de estados. Solución: a) Define un formato válido para las instrucciones aritmético-lógicas de la nueva máquina, especificando todos los campos de las instrucciones y su significado, sin modificar la longitud total de las instrucciones, ni la longitud de los operandos inmediatos. Existen varias posibilidades para la codificación, con objeto de no modificar la lógica de selección en el multiplexor de entrada a la ALU, proponemos el siguiente formato, en el que se utilizan los bits IR4-3, para asignar los nuevos códigos. De esta forma, todas las operaciones que utilizan dos operandos en registro tienen asignado un código de OP con IR2 % 1. Instrucción

Código IR15-14

4 bits IR13-116

4 bits IR10-8

4 bits IR7-5

2 bits IR4-3

3 bits IR2-0

ADD

11

RD

RF1

RF2

00

100

SUB

11

RD

RF1

RF2

00

101

ASR

11

RD

—

RF2

00

110

AND

11

RD

RF1

RF2

00

111

XOR

11

RD

RF1

RF2

01

100

NOT

11

RD

—

RF2

01

101


219

b) Diseña la nueva ALU teniendo en cuente las decisiones del apartado anterior. Para la identificación de las nuevas operaciones en los bits de control de la ALU utilizaremos la función: F % IR3IR2. Función a realizar por el multiplexor de selección de la ALU (que pasa a ser de 8 a 1 en vez de 4 a 1): F

IR1

IR0

Instrucción

0

0

0

ADD

0

0

1

SUB

0

1

0

ASR

0

1

1

AND

1

0

0

XOR

1

0

1

NOT

1

1

0

—

1

1

1

—

Y la propuesta de nueva arquitectura interna de la ALU es:

220


PROBLEMA 18 La tabla representa un programa en lenguaje máquina de la MR. Dir

HEX

00

F818

01

FF09

02

9005

03

7F06

04

8001

05

C004

Código máquina

a) Traduce a ensamblador las instrucciones. b) Si el programa se detiene tras ejecutar la instrucción de la dirección 05, ¿qué habrá almacenado en la dirección de memoria 06? c)

¿Cuántas veces se ejecuta la instrucción de la dirección 01?

Solución: a) Traduce a ensamblador las instrucciones. Código máquina

Dir

HEX

IR15 IR14 IR13 IR12 IR11 IR10 IR9 IR8 IR7 IR6 IR5 IR4 IR3 IR2 IR1 IR0

00

F818

1111 1000 0001 1000

1

1

1

1

1

0

0

0

0

0

0

1

1

0

0

0

01

FF09

1111 1111 0000 1001

1

1

1

1

1

1

1

1

0

0

0

0

1

0

0

1

02

9005

1001 0000 0000 0101

1

0

0

1

0

0

0

0

0

0

0

0

0

1

0

1

03

7F06

0111 1111 0000 0110

0

1

1

1

1

1

1

1

0

0

0

0

0

0

0

1

04

8001

1000 0000 0000 0001

1

0

0

0

0

0

0

0

0

0

0

0

0

0

0

1

05

C004

1100 0100 0000 0000

1

1

0

0

0

0

0

0

0

0

0

0

0

1

0

0

Interpretando los bits IR15IR14 podemos ver qué tipo de instrucción estamos codificando y en el caso de las instrucciones ALU, además IR2 para saber si es una operación con inmediato o entre registros:


Dir

HEX

Código máquina

IR15IR14

IR2

Tipo

00

F818

1111 1000 0001 1000

11

0

ALU con inmediato

01

FF09

1111 1111 0000 1001

11

0

ALU con inmediato

02

9005

1001 0000 0000 0101

10

1

Salto

03

7F06

0111 1111 0000 0110

01

1

STORE

04

8001

1000 0000 0000 0001

10

0

Salto

05

C004

1100 0000 0000 0100

11

1

ALU entre registros

221

Aplicando el siguiente formato de instrucciones obtendremos los operandos, condiciones y códigos OP de las instrucciones correspondientes. ALU entre registros

Código IR15-14

RD IR13-11

RF1 IR10-8

RF2 IR7-5

XX IR4-3

Salto

Código IR15-14

COND IR13-11

000 IR10-8

Dirección IR7-0

STORE

Código IR15-14

RD IR13-11

RI IR10-8

Dirección IR7-0

LOAD

Código IR15-14

RF IR13-11

RI IR10-8

Dirección IR7-0

Instrucción ensamblador

OP IR2-0

Dir

HEX

00

F818

ALU con inmediato

Código IR15-14 11

RD RF1 IR13-11 IR10-8 111 000

Inmediato IR7-2 00011

OP IR2-0 000

ADDI R0,Ⲇ3,R7

01

FF09

ALU con inmediato

Código IR15-14 11

RD RF1 IR13-11 IR10-8 111 111

Inmediato IR7-2 00001

OP IR2-0 001

SUBI R7,Ⲇ1,R7

02

9005

Salto

Código IR15-14 10

COND 000 IR13-11 IR10-8 010 000

Dirección IR7-0 0000 0101

BL 05h

03

7F06

STORE

Código IR15-14 01

RF RI IR13-11 IR10-8 111 111


STORE R7, 06(R7)

04

8001

Salto

Código IR15-14 10

COND 000 IR13-11 IR10-8 000 000


BR 01h

05

C004

ALU entre registros

Código IR15-14 11

RD RF1 IR13-11 IR10-8 000 000

RF2 IR7-5 000

Instrucción

XX IR4-3 00

OP IR2-0 100

ADD R0,R0,R0

222


b) Si el programa se detiene tras ejecutar la instrucción de la dirección 05, ¿qué habrá almacenado en la dirección de memoria 06? La ejecución completa del programa será: ADDI R0,#3,R7; SUBI R7,# # 1,R7 BL 05h; STORE R7, 06(R7); BR 01h; SUBI R7,# # 1,R7 BL 05h; STORE R7, 06(R7); BR 01h; SUBI R7,# # 1,R7 BL 05h; STORE R7, 06(R7); BR 01h; SUBI R7,# # 1,R7 BL 05h; ADD R0,R0,R0; END

c)

R7=3 R7=R7-1=2 NO SALTA MEM[8]=R7=2 SALTA A LA POSICIÓN 1 R7=R7-1=1 NO SALTA MEM[7]=R7=1 SALTA A LA POSICIÓN 1 R7=R7-1=0 NO SALTA MEM[6]=R7=0 SALTA A LA POSICIÓN 1 R7=R7-1=-1 SALTA A O5h PORQUE LA OPERACIÓN ANTERIOR FUE<0 nop

El contenido de la posición 6 será por lo tanto MEM[06h] %0000h. ¿Cuántas veces se ejecuta la instrucción de la dirección 01? Cuatro.

PROBLEMA 19 Considere que el tiempo de respuesta de los diferentes elementos de la ruta de datos de la máquina rudimentaria es el siguiente: 45 ns para los multiplexores 10 ns para el incrementador del PC 25 ns para el sumador de direcciones 40 ns para el extensor de signo 20 ns para la evaluación de la condición de salto 70 ns para leer un registro del banco de registros 120 ns el tiempo de respuesta de la ALU con operaciones aritmético-lógicas 25 ns el tiempo de respuesta de la ALU cuando la información pasa sin operar. 80 ns para una lectura de memoria y 120 ns para una escritura. ¿Cuál sería el período mínimo de la señal de reloj para poder ejecutar correctamente una instrucción en la MR siguiendo el diagrama simplificado? Solución: Para averiguar el período mínimo debemos calcular el retardo de todas las fases de ejecución, y para esto debemos analizar qué operaciones realiza la unidad de proceso. Suponiendo el diagrama de estados simplificado de la máquina rudimentaria, tenemos:


223

ESTADO FETCH: tPCpPC!1 % tMULTIPLEXOR ! tINCREMENTADOR % 55 ns tIRpMEM[PC] % tMULTIPLEXOR ! tLECTURA–MEMORIA % 125 ns ESTADO DECO: tLECTURA–DEL–PRIMER–OPERANDO % tMULTIPLEXOR ! tLECTURA–BANCO–REGISTROS % 115 ns tCÁLCULO–DIRECCIÓN %tMULTIPLEXOR !tLECTURA–BANCO !tSUMADOR–DIRECCIONES %140 ns tEVALUACIÓN–DE–CONDICIÓN % 20 ns ESTADO LOAD: tESCRITURA–EN–BANCO–DESDE–MEMORIA % tMULTIPLEXOR ! tLECTURA–DE–MEMORIA ! ! tMULTIPLEXOR ! tALU % 195 ns ESTADO STORE: tSELECCIÓN–DE–LA–DIRECCIÓN % tMULTIPLEXOR % 45 ns tESCRITURA–EN–MEMORIA–DESDE–BANCO % tMULTIPLEXOR ! tLECTURA–BANCO–REGISTROS ! ! tESCRITURA–EN–MEMORIA % 235 ns ESTADO ARIT: tSEGUNDO–OPERANDO–Y–ALU % tMULTIPLEXOR ! tLECTURA–BANCO–REGISTROS ! ! tMULTIPLEXOR ! tALU % 280 ns tIRpMEM[PC] % tMULTIPLEXOR ! tLECTURA–MEMORIA % 125 ns tPCpPC!1 % tMULTIPLEXOR ! tINCREMENTADOR % 55 ns ESTADO BRANCH: tIRpMEM[R@] % tMULTIPLEXOR ! tLECTURA–MEMORIA % 125 ns tPCpR@!1 % tMULTIPLEXOR ! tINCREMENTADOR % 55 ns El estado que más tiempo necesita para ejecutarse será el de ARIT, que tiene un tiempo de lectura del segundo operando y realización de la operación aritmético-lógica de 280 ns, por lo tanto éste será el tiempo ciclo mínimo que debemos asignar al procesador para que funcione correctamente con todas las instrucciones. PROBLEMA 20 Considere el siguiente programa, escrito en código ensamblador de la MR: 03h 04h 05h 06h 07h 08h 09h

LOAD 0(R0),R1 SUBI R1,#6,R1 BLE 7 BR 9 LOAD 1(R0),R2 STORE R1,2(R0) ADD R1,R2,R3

224


a) Indique el orden de ejecución del código. b) ¿Cuánto tiempo tardaría en ejecutarse en la máquina del apartado a) si ésta sigue el diagrama simplificado de la MR y tiene un tiempo de ciclo de 50 ns? c)

Calcule el tamaño del código (n.o de bits) del programa.

Solución: a) Indique el orden de ejecución del código. Suponiendo que se empieza a ejecutar por la primera instrucción (dirección 03h) y que las otras posiciones están vacías: 03h 04h 05h 07h 08h 09h

LOAD 0(R0),R1; SUBI R1,#6,R1; BLE 7; LOAD 1(R0),R2; STORE R1,2(R0); ADD R1,R2,R3;

R1=MEM[0]=0000h R1=R1-6=-6 SALTA A 07h R2=MEM[1]=0000h MEM[2]=-6 R3=R1+R2=-6

b) ¿Cuánto tiempo tardaría en ejecutarse en la máquina del apartado a) si ésta sigue el diagrama simplificado de la MR y tiene un tiempo de ciclo de 50 ns? Para calcular el tiempo que tarda en ejecutarse debemos ver por qué fases pasa cada instrucción, contar el total de fases que se ejecutan según el apartado a) y multiplicar por el tiempo de ciclo: 03h 04h 05h 07h 08h 09h

LOAD 0(R0),R1; SUBI R1,#6,R1; BLE 7; LOAD 1(R0),R2; STORE R1,2(R0); ADD R1,R2,R3;

FETCH+DECO+LOAD FETCH+DECO+ARIT DECO+BRANCH DECO+LOAD FETCH+DECO+STORE FETCH+DECO+ARIT

En total son 16 ciclos y por lo tanto el tiempo de ejecución total del programa será 16*50 ns % 800 ns. c)

Calcule el tamaño del código (n.o de bits) del programa. Si la palabra de memoria son 16 bits, el tamaño del programa Sprograma será: Sprograma % 16 bits * 7 instrucciones % 112 bits

5.6 Problemas propuestos PROBLEMA 1 El diagrama siguiente representa una posible codificación de la unidad de control de la máquina rudimentaria. Implemente la unidad de control mediante un contador módulo 8 (con señal de Load prioritaria sobre la de Contar y Reset asíncrono). La máquina secuencial sólo debe representar las transiciones de estados (no es necesario implementar las salidas de la UC en cada estado) en función de las señales Cond, OP15 y OP14.


225

PROBLEMA 2 Partiendo del diagrama de estados de la MR simplificado, indica cuántos ciclos tardará en ejecutarse el siguiente programa: SUB R1, R2, R5 ADDI R3, Ⲇ1, R1 LOAD 3(R5), R1 STORE R4, 1(R4) ASR R2, R7 PROBLEMA 3 a) Suponiendo que el tiempo de respuesta de los diferentes elementos de la UP de MR es el siguiente, indique la frecuencia máxima de reloj a la que puede trabajar la máquina rudimentaria teniendo en cuenta que los multiplexores no retardan las señales y que el estado más lento es el de LOAD: 10 ns para el multiplexor SELDIR. 20 ns para los multiplexores SELREG y SELDAT. 15 ns para el incrementador del PC y para el sumador de direcciones. 80 ns para el extensor de signo. 20 ns para la evaluación de la condición de salto. 40 ns para leer un registro del banco de registros. 120 ns el tiempo de respuesta de la ALU. 40 ns para una lectura de memoria y 100 ns para una escritura.

226


b) ¿Cuál sería el período mínimo de la señal de reloj para poder ejecutar correctamente una instrucción de STORE en la MR modificada? (considere cada etapa que puede atravesar una instrucción de STORE). c)

Imagine ahora que una escritura en memoria tarda 180 ns, pero no queremos modificar el período de reloj determinado anteriormente. ¿Funcionará la MR correctamente?

PROBLEMA 4 a) ¿Cuál es la instrucción de la MR que se codifica en hexadecimal 1234? b) ¿Cuál es la codificación de SUBI R1,Ⲇ2,R3 en hexadecimal? PROBLEMA 5 Sea un computador de características similares a la máquina rudimentaria pero con las siguientes modificaciones: Una memoria ampliada a 32 K palabras. Un repertorio de 128 instrucciones aritmético-lógicas, además de las otras. a) Dar un posible formato para las instrucciones que aproveche el máximo número de bits. b) ¿Ha cambiado el registro R@? ¿Por qué? c)

¿Ha cambiado el rango del número inmediato? ¿Por qué?

d) ¿Por qué motivo se puede realizar en una sola fase la descodificación de la instrucción, la evaluación de la condición, el cálculo de la dirección efectiva y la búsqueda del primer operando? e)

Suponer que los multiplexores tienen un retardo de 5 ns, los sumadores de 35 ns, leer en el banco de registros y evaluar la condición de salto de 40 ns y la ALU y la memoria de 110 ns, ¿cuánto tardará en ejecutarse la fase descrita en el apartado anterior? Razona la respuesta.

PROBLEMA 6 Considere el siguiente programa escrito en código ensamblador de la MR: .ORG DATOS: RES: .BEGIN INICIO:

SIGUE: FIN:

100 .DW 5,0 .RW 1 INICIO LOAD 100(R0),R1 SUBI R1,#6,R1 BLE SIGUE BRA FIN LOAD 101(R0),R2 STORE R1,RES(R0) ADD R1,R2,R3 .END

a) Indique el orden de ejecución del código. b) ¿Cuántos ciclos tarda en ejecutarse usando el diagrama simplificado de la MR?


c)

227

¿En qué dirección está almacenada la instrucción LOAD 101(R0),R2 ?

d) Especifique el contenido de los registros PC y R@ durante las fases DECO y BRANCH de la instrucción BRA fin. e)

Indique el contenido de los registros RZ y RN tras la ejecución de la instrucción LOAD 101(R0),R2 . ¿Y tras ejecutar la instrucción STORE R1,res(R0) ?

f)

Calcule el tamaño del código del programa. ¿Cuál sería el tamaño de este mismo código si la máquina rudimentaria dispusiera de 32 registros de propósito general en lugar de solamente 8?

PROBLEMA 7 Considere que el tiempo de respuesta de los diferentes elementos de la ruta de datos de la máquina rudimentaria es el siguiente: 15 ns para el multiplexor SELDIR. 25 ns para los multiplexores SELREG y SELDAT. 25 ns para el incrementador del PC. 30 ns para el sumador de direcciones. 5 ns para el extensor de signo. 20 ns para la evaluación de la condición de salto. 50 ns para leer un registro del banco de registros. 125 ns el tiempo de respuesta de la ALU con operaciones aritmético-lógicas. 35 ns el tiempo de respuesta de la ALU cuando la información pasa sin operar. 50 ns para una lectura de memoria y 90 ns para una escritura. Sabiendo que la fase de instrucción que más tarda en ejecutarse es la fase de ARIT, ¿cuál sería la frecuencia máxima de trabajo? PROBLEMA 9 Indique cómo afectaría a los elementos de la ruta de datos y al formato de instrucciones de la MR las siguientes modificaciones por separado y de forma acumulativa para cada apartado: a) Cambiar la memoria de 256 palabras por una de 2 K. b) Un banco de registros de 64 posiciones. c)

En las operaciones aritmético-lógicas el segundo operando indica tanto el registro fuente 2 como el registro de destino.

d) Implementar 32 operaciones aritmético-lógicas. PROBLEMA 10 Para hacer más rápidos los movimientos de datos vamos a cambiar la instrucción LOAD, de modo que ahora ya no modifica los bits N y Z. a) Dibujar detalladamente la unidad de proceso con este cambio. b) ¿Habría algun cambio en la ALU?

a

Una vez que se ha estudiado en el capítulo anterior el formato de instrucciones y el significado de las mismas para el procesador, vamos a estudiar diversos ejemplos de programación en ensamblador. El lenguaje ensamblador permite al programador realizar programas en un lenguaje mnemónico que facilite la tarea de especificar al procesador las operaciones que debe realizar. Una vez ensamblado el programa se obtiene un código máquina o binario (instrucciones codificadas en binario) que es lo que comprende en realidad la máquina ya que, como se ha explicado en el capítulo anterior, de estas instrucciones el procesador puede obtener toda la información importante para implementar el programa solicitado. Un programa en ensamblador se compone básicamente de instrucciones y directivas. Las directivas son partes del programa que se encargan de controlar las acciones auxiliares necesarias para el proceso de ensamblado, definir variables y constantes, reservar posiciones de memoria, identificar partes de comienzo, fin y etiquetas para implementar los bucles, especificar posiciones de memoria donde se almacenan los datos o definir bloques autocontenidos (macros). Las instrucciones son las que implementan el programa como tal. En este capítulo se ha utilizado el lenguaje ensamblador de la máquina rudimentaria explicado anteriormente, aunque los conceptos son extensibles a otras arquitecturas. Para implementar un programa en ensamblador seguiremos el proceso siguiente. Primero obtenemos el pseudocódigo, a partir de él el diagrama de flujo y después se traduce a código en ensamblador. El repertorio de instrucciones que vamos a seguir es el siguiente.

230


6.1 Instrucciones aritmético-lógicas Instrucción

Descripción

Notación

ADD RF1,RF2,RD

Suma el contenido de dos registros (RF1 y RF2) y lo almacena en otro registro (RD)

RDpRF1!RF2

SUB RF1,RF2,RD

Resta el contenido de dos registros (RF1 y RF2) y lo almacena en otro registro (RD)

RDpRF1-RF2

ASR RF,RD

Desplazamiento a la derecha de RF y almacena el resultado en RD. Mantiene signo

RDpARF

AND RF1,RF2,RD

Multiplicación lógica (AND) del contenido de dos registros (RF1, RF2) y almacena el resultado en otro RDpRF1(AND)RF2 registro (RD)

ADDI RF1,ⲆNUM,RD

Suma el contenido de un reg. (RF1) con un número inmediato (ⲆNUM) y almacena el resultado en otro registro (RD)

RDpRF1!ⲆNUM

SUBI RF1,ⲆNUM,RD

Resta el contenido de un reg. (RF1) con un número inmediato (ⲆNUM) y almacena el resultado en otro registro (RD)

RDpRF1-ⲆNUM

Todas ellas actualizan los bits de condición Z y N.

6.2 Instrucciones de acceso a memoria Instrucción

Descripción

Notación

LOAD A(RI),RD

Carga el contenido de la dirección efectiva (E.A). en el registro RD E.A. % RI ! A

RDpMEM[RI!A]

STORE RF, A(RI)

Almacena el contenido del registro RF en la posición de memoria (E.A). E.A. % RI ! A

RDpMEM[RI!A]

Sólo LOAD actualiza los bits de condición Z y N.

6.3 Instrucciones de salto (BCC) Las instrucciones de salto evalúan una condición con respecto a la anterior instrucción. Para evaluar si se cumple o no la instrucción se comprueba el valor de los registros de estado N y Z, que habrán sido modificados por la instrucción anterior.

Capítulo 6 Introducción a la programación en lenguaje ensamblador

Instrucción

Descripción

BL DIR

Salta a DIR si menor (si N % 1)

BG DIR

Salta a DIR si mayor (si N % 0 y Z % 0)

BEQ DIR

Salta a DIR si igual (si Z % 1)

BNE DIR

Salta a DIR si distinto (si Z % 0)

BLE DIR

Salta a DIR si menor o igual (si N % 1 o Z % 1)

BGE DIR

Salta a DIR si mayor o igual (si N % 0 o Z % 1)

BR DIR

Salto incondicional % Salta siempre a DIR

231

Ninguna modifica los bits de estado.

6.4 Directivas Directiva

Operación

.DW VALOR1, VALOR2, ... VALORN

Define N posiciones de memoria consecutivos con valores iniciales VALOR1, VALOR2, ... VALORN

.RW N

Reserva N posiciones de memoria consecutivas sin valor inicial

IDENTIFICADOR % VALOR

Define un identificador con el valor asociado al valor, por ejemplo una constante

.BEGIN ETIQUETA

Indica la instrucción de comienzo de ejecución. Para identificarla en el programa aparecerá la instrucción precedida de: ETIQUETA:

.END

Indica el final de la ejecución del programa

.ORG VALOR

Indica que la instrucción escrita a continuación se almacenará en la posición de memoria dada por VALOR

.DEF NOMBRE MACRO – PARAMETROS

Indica el inicio de una macro (similar a una subrutina)

.ENDDEF

Indica el final de una macro

6.5 Diagramas de flujo Para realizar el diagrama de flujo, identificaremos los bloques más habituales a partir de los cuales desarrollaremos el código. Un ejemplo de este proceso se recoge en el problema 1 y en el resto de problemas resueltos el lector puede encontrar ejemplos de cómo se traducen los bloques recogidos en las figuras siguientes.

232


Nota aclaratoria: En todos los problemas resueltos en este capítulo tanto las instrucciones como las directivas las escribiremos en mayúsculas.

6.6 Problemas resueltos PROBLEMA 1 El siguiente algoritmo cambia el signo de todos los números negativos de un vector «v» de N elementos. Traducir el siguiente pseudocódigo a ensamblador de la máquina rudimentaria: for i:%0 to N-1 if v[i]a0 then v[i]:%0-v[i]; end end


233

Solución: En este primer ejercicio y con objeto de simplificar vamos a obviar la forma en cómo han llegado los datos a la memoria. El vector «V» se encuentra almacenado de modo que cada elemento ocupa 1 palabra. Para localizar el vector en memoria basta con conocer la dirección del primer elemento. Supongamos que esta dirección tiene asignada la etiqueta «V». Del mismo modo hemos asignado otra a etiqueta «N» el número de elementos que tiene el vector. Lo primero que vamos a hacer es realizar el diagrama de flujo que se corresponde con el algoritmo solicitado. Comenzaremos dibujando el diagrama del FOR-TO, particularizando el contador con «i». A continuación, nos ocuparemos del cuerpo del for, que en este caso incluye un bloque IF-THEN. Una vez dibujado el esquema del bloque, nos ocupamos del cuerpo del THEN, que se trata de una simple asignación y que, en principio, ya no se puede descomponer más. El diagrama mostrado en la figura, así construido, supone una buena aproximación.

Sin embargo, la máquina rudimentaria aún no sería capaz de ejecutarlo. El motivo es que las asignaciones presentes no hacen referencia a los componentes de la máquina. Es decir, es necesario particularizar el diagrama de flujo a los registros e instrucciones de nuestra máquina. Una forma sencilla de realizar este proceso es hacer una pasada más detallada sobre el diagrama de flujo general: i p Ⲇ0: La variable «i» es el contador del FOR. Por lo tanto conviene utilizar uno de los 8 registros del banco. El registro elegido hará las veces de «i» a lo largo del diagrama. Por ejemplo R1. v[i] , Ⲇ0: La comparación es en definitiva una resta y por tanto una operación aritmética. Por ello es necesario que al menos su primer operando tenga direccionamiento directo (el segundo puede ser directo o inmediato como es el caso). La solución es descomponer este rombo en dos: Primero volcar el contenido de v[i] en un registro libre (R2, por ejemplo) y después comparar el contenido de dicho registro con Ⲇ0. v[i] p 0 . v[i]: Esta instrucción también es demasiado compleja para la máquina rudimentaria. De nuevo se trata de una resta y por tanto el primer operando debe encontrarse

234


en el banco de registros. La solución es elegir el registro R0, que siempre vale 0. El segundo operando es v[i]; pero este dato está almacenado en R2. Por último el resultado de una operación aritmética se debe volcar siempre en un registro. Elegimos por ejemplo R3. Con todo, la instrucción debería ser: R3 p R0 . R2. Pero es necesario una caja más para volcar el contenido de R3 en la palabra v[i]. Teniendo en cuenta esto se redibuja el diagrama de flujo con más detalle:

Recorriendo el diagrama en vertical, comenzando por arriba, y traduciendo cada caja al lenguaje máquina de la máquina rudimentaria finalmente se obtiene: .BEGIN INICIO V: .DW -1,-2,-3,-4,-5,-6 N: .DW 6 INICIO: ADDI R0,#0,R1 FOR: SUBI R1,#N,R0 BGE FIN LOAD V(R1),R2 SUBI R2,#0,R0 BGE INC SUB R0,R2,R3 STORE R3,V(R1) INC: ADDI R1,#1,R1 BR FOR FIN: .END


235

PROBLEMA 2 Traducir el siguiente pseudocódigo a ensamblador: Vsize: 10; {VSIZE ES UNA CONSTANTE, NO UNA ETIQUETA} V: [2,-3,5,1,-6,0,0,3,5,4]; W: vector vacio de Ⲇvsize elementos; For i:%0 to Vsize-1 W[i]:%V[Vsize-1-i]; Solución: En este ejemplo podemos reutilizar el bloque for del problema anterior. Reservamos las variables y definimos las constantes: .BEGIN INICIO VSIZE=10 V: .DW 2,-3,5,1,-6,0,0,3,5,4 W: .RW 10 INICIO: ADDI R0,#0,R1; R1=I ADDI R0,#VSIZE,R2; R2=N SUBI R2,#1,R2; R2=N-1 FOR: SUBI R1,#VSIZE,R0 BGE FIN SUB R2,R1,R3; R3=N-1-I LOAD V(R3),R4 STORE R4,W(R1) ADDI R1,#1,R1 BR FOR FIN: .END

PROBLEMA 3 Traducir el siguiente pseudocodigo a ensamblador: (Dibujar también el diagrama de flujo) Vsize=7 v : [4,9,6,0,8,3,7] k :% 6; x:%0; repeat if (v[k]b5) AND (x=0) then w[k]:= v[k]!2 else x:=v[k]; w[k]:=0 endif k:=k!1; until ka0

236


Solución:


.BEGIN

237

INICIO

VSIZE=7 V:

.DW 4,9,6,0,8,3,7

W:

.DW -1,-1,-1,-1,-1,-1,-1

K:

.DW 6

X:

.DW 0

INICIO: LOAD K(R0),R1; R1:=K REPEAT: LOAD V(R1),R3; R3:=V(K) SUBI R3,#5,R0; R3b5? BLE ELSE LOAD X(R0),R2; R2:=X SUBI R2,#0,R0; R2=0? BNE ELSE ADDI R3,#2,R4; W(k):=V(K)!2 STORE R4,W(R1) BR FINIF ELSE:

STORE R3,X(R0); X:=V(K) STORE R0,W(R1); W(K):=0

FINIF:

SUBI R1,#1,R1 BGE REPEAT ;EL RESULTADO DEBE SER W=[0,B,8,0,0,0,9]

.END

PROBLEMA 4 Codificar el siguiente algoritmo en el lenguaje máquina de la MR. Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible. v % [2 0 8 1]; X % 1; Y % 2; Vsize%4; {--Algoritmo--} for k%0 to vsize.1 while (Xa3)and(YaX) X:%v(k); v(k):%Y; x:%x!y; y:%y.1; end

238


Solución:

.BEGIN INICIO V: .DW 2,0,8,1 X: .DW 1 Y: .DW 2 INICIO: LOAD X(R0),R1; R1<-X LOAD Y(R0),R2; R2<-Y ADD R0,R0,R7; R7<-0 FOR:SUBI R7,#4,R0; vsize=4


BGE FIN WHILE: SUBI R1,#4,R0; X<3? BGE INC SUB R2,R1,R0; Y
El resultado debe ser: Posición

Contenido

Variable

00

0002

V(0)

01

0001

V(1)

02

0000

V(2)

03

0001

V(3)

04

0007

X

05

FFFE

Y

PROBLEMA 5 Codificar en el lenguaje de la máquina rudimentaria el siguiente algoritmo: VSIZE=7; V=[0,2,4,1,5,3,7]; W=ARRAY[0..VSIZE-1]; X=0; FOR K=0 TO VSIZE-1 IF (V[K]<=3 AND (X=0) THEN W[K]:=X-V[K]; ELSE X:=X+1; W[K]:=0; END END

239

240


Solución:

.BEGIN

INICIO

VSIZE=7; V

.DW 0,2,4,1,5,3,7

W

.RW VSIZE

X

.DW 0

INICIO:

ADD R0,R0,R1

FOR:

SUBI R1, #VSIZE,R0 BGE FIN LOAD V(R1),R2 LOAD X(R0),R3


241

SUBI R2,#3,R0 BG ELSE SUBI R3,#0,R0 BNE ELSE THEN:

SUB R3,R2,R4 STORE R4, W(R1) BR FINIF

ELSE:

ADDI R3,#1,R3 STORE R0, W(R1)

FINIF:

ADDI R1,#1,R1 BR FOR

FIN:

STORE R3,X(R0) .END

PROBLEMA 6 Reescribe el siguiente algoritmo en el lenguaje de la máquina rudimentaria. Dibuja también el diagrama de flujo. vsize % 8 V: vector vació de Ⲇvsize elementos W: [-3, -2, -1, 0, 2, 4, 6, 8] cont :% 1; While (cont m 7) If W(cont-1) n W(cont!1) then V(cont)%W(cont)/2; Else V(cont)%15; cont :% cont ! 1; endWHILE Solución: Vamos a utilizar R1 para llevar el contador (cont), R2 para ir cargando los componentes del vector W y R4 para cargar los componentes del vector V. Utilizaremos además dos registros auxiliares R3 y R4 para almacenar las posiciones de los vectores con índice (i ! 1) e (i . 1). En realidad este paso no sería necesario, ya que se podría hacer con un direccionamiento en la instrucción de LOAD directamente, pero pretendemos ilustrar cómo se haría en caso de que no fuera posible realizar esta carga directamente.

242


El diagrama de flujo será:


.BEGIN VSIZE=8 V: W: INICIO: WHILE:

ELSE: ENDWHILE:

FIN:

243

INICIO .RW 8 .DW -3,-2,-1,0,2,4,6,8 ADDI R0,#1,R1; CONT=R1=1 LOAD W(R1),R2; R2<-W(CONT) SUBI R1,#7,R0; CONT<=7? BG FIN ADDI R1,#1,R3; R3=CONT+1 SUBI R1,#1,R4; R4=CONT-1 LOAD W(R4),R5; R5=W(R1-1) LOAD W(R3),R6; R6=W(R1!1) SUB R5,R6 BL ELSE ASR R2,R7 BR ENDWHILE ADDI R0,#15,R7 STORE R7,V(R1) ADDI R1,#1,R1 BR WHILE .END

PROBLEMA 7 Codificar el siguiente algoritmo en el lenguaje máquina de la MR. Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible. v % [2 0 8 1]; X % 1; Y % 2; {--Algoritmo--} for k%0 to vsize-1 if (Xa3)or(YaX) Y:%v(k); v(k):%X; X!!; end

244


Solución:

.BEGIN V: X: Y: VSIZE%4 INICIO: FOR:

INICIO .DW 2,0,8,1 .DW 1 .DW 2 ADDI R0,#0,R1 SUBI R1,#VSIZE,R0 BGE FIN LOAD X(R0),R2 LOAD Y(R0),R3 SUBI R2,#3,R0 BL THEN SUB R3,R2,R0


THEN:

INC: FIN:

245

BGE INC LOAD V(R1),R3 STORE R2,V(R1) STORE R3,Y(R0) ADDI R2,#1,R2 STORE R2,X(R0) ADDI R1,#1,R1 BR FOR; EL RESULTADO FINAL ES V=[1,2,1,0] .END

PROBLEMA 8 Dado el siguiente código: inicio SUBI R0,Ⲇ1,R0 BEQ fin ADD R1,R0,R2 fin STORE R2,X(R0) a) ¿Cuántas veces se ejecuta la instrucción «ADD»? b) ¿Qué valor debe tener R1 al comienzo del programa para que al terminar la ejecución X valga 5? Solución: Para responder al apartado a) debemos seguir el funcionamiento del programa. La primera instrucción es: inicio SUBI R0,#1,R0

En esta instrucción realizamos la operación 0 . 1 % .1, con lo que después de esta operación no se realiza escritura en los registros, pero el bit Z valdrá 0 y el bit N será 1, ya que el resultado de la operación es negativa: BEQ fin

Esta instrucción no bifurca por lo explicado para la primera instrucción ADD R1,R0,R2

Esta instrucción realice la operación: R2 p R1 ! R0 % R1 fin

STORE

R2,X(R0)

Almacenamos el valor de r2 en la posición de la variable x. Por la tanto, no hay paradas en la ejecución y sólo se ejecuta una vez. b) Es evidente que R1 debe valer 5 al principio del programa para que al terminar la ejecución X valga 5. PROBLEMA 9 Codificar el siguiente algoritmo en el lenguaje máquina de la MR(1.25). Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible.

246


v % [2 .4 6 .8]; X % 0; Y % .1; {--Algoritmo--} while (Xavsize)and(YaX) begin if v(X)b0 then v(x):%y; X:%X!1; end Solución:


247

.BEGIN INICIO ;Reservamos las variables y definimos las constantes: V: .DW 2,-4,6,-8 X: .DW 0 Y: .DW -1 VSIZE=4 INICIO: LOAD X(R0),R1; R1=X LOAD Y(R0),R2; R2=Y WHILE: SUBI R1,#VSIZE,R0 BGE FIN SUB R2, R1,R0 BGE FIN LOAD V(R1),R3; RE%V(K) SUBI R3,#0,R0 BLE FINIF STORE R2, V(R1) FINIF: ADDI R1,#1,R1 BR WHILE FIN: STORE R1,X(R0) ; ; EL CONTENIDO FINAL DE LAS 4 ; PRIMERAS POSICIONES DE MEMORIA DEBE SER: ; 00 FFFF ; 01 FFFC ; 02 FFFF ; 03 FFF8 .END

PROBLEMA 10 Codificar el siguiente algoritmo en el lenguaje máquina de la MR(1.25). Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible. N%8 v % [-4 -3 -2 -1 0 1 2 3]; w % vector de N elementos; {--Algoritmo--} k:%0; x:%0; while (kaN)and(x%0) begin if v(X)b0 then x:%x!1; w(k):%v(k)!4; k:%k!1; end

248


Solución:


.BEGIN N=8 V: W: INICIO: WHILE:

FINIF:

FIN:

249

INICIO .DW -4,-3,-2,-1,0,1,2,3 .RW 8 ADDI R0,#0,R1; K=0 ADDI R0,#0,R2; X%0 SUBI R1,#N,R0; K
PROBLEMA 11 Codificar el siguiente algoritmo en el lenguaje máquina de la MR(1.25). Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible (1.25). N%4 v % [-2, 4, -6, 8] w % vector de N elementos x%1 y%0 Begin for k :% 0 to N-1 begin w(k)%0 if v(k)ay AND x%N then x:%x!2 else w(k):%v(k)!1 end end End.

250


Solución:


251

.BEGIN INICIO N=4 V: .DW -2, 4,-6,8 W: .RW 4 X: .DW 1 Y: .DW 0 INICIO: LOAD X(R0),R3 LOAD Y(R0),R2 ADD R0,R0,R7; R7=K IF: SUBI R7,#N,R0 BGE FIN LOAD V(R7),R1 STORE R0, W(R7) SUB R1,R2,R0 BGE ELSE SUBI R3,#N,R0 BG ELSE THEN: ADDI R3,#2,R3 BR INCK ELSE: ADDI R1,#1,R4 STORE R4,W(R7) INCK: ADDI R7,#1,R7 BR IF FIN: STORE R3,X(R0) STORE R2, Y(R0); W=[0,5,0,9] .END

PROBLEMA 12 Codificar el siguiente algoritmo en el lenguaje máquina de la MR. Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible (1.25). N%6 v % [-1, -2, 3, 4, -5, 5] w % vector de N elementos Begin for k :% 0 to N-1 begin w(k):%v(k)!1; if w(k)b0 AND kmN-2 then w(k):%w(k)!v(k!1); end end End.

252


Solución:


.BEGIN

INICIO

N%6 V:

.DW -1,-2,3,4,-5,5

W:

.RW 6

INICIO:

ADDI R0,#0,R1; R1=K

FOR: SUBI R1,#N,R0; BGE FIN LOAD V(R1),R2; R2<-V(K) ADDI R2,#1,R3; W(K)=V(K)!1 STORE R3,W(R1) SUBI R3,#0,R0; R3>0? BLE INC SUBI R1,#4,R0 BL THEN SUBI R3,#0,R0 BLE INC ADDI R2,#1,R2 STORE R2,V(R2) THEN:

ADD R2,R3,R3 STORE R3, W(R1)

INC: ADDI R1,#1,R1 BR FOR FIN: .END

PROBLEMA 13 Traducir el siguiente pseudocódigo a ensamblador: Vsize%10 v : [0,1,2,3,4,5,6,7,8,9] w : vector vacio de ⲆVsize elementos For i :% 0 to Vsize-1 If (v[i]b%3) Then w[i]:%0 Else w[i]:%v[i!1]

253

254


Solución:

.BEGIN

INICIO

V:

.DW 0,1,2,3,4,5,6,7,8,9

W:

.RW 10

VSIZE=10 INICIO: ADDI R0,#0,R1;

R1:=i

FOR:

SUBI R1,#VSIZE,R0;

Comparar (i, VSIZE)

BGE FIN;

Salta si i>=VSIZE

LOAD V(R1),R2;

R2:=V[i]

IF: THEN:

SUBI R2,#3,R0;

Comparar (V[i],3)

BL ELSE;

Salta si V[i]a3

STORE R0,W(R1); BR INC–I

ELSE:

INC–I:

ADDI R1,#1,R2; LOAD V(R2),R2;

R2:=V[i+1]

STORE R2, W(R1);

ELSE W[i]:=V[I+1]

ADDI R1,#1,R1;

i++

BR FOR FIN:

R2:=i+1

.END


255

PROBLEMA 14 Dadas las siguientes instrucciones y el contenido de los registros especificado y sabiendo que el contenido inicial de la posición de memoria 0003h es 0101h, indicar el contenido de los registros después de la ejecución de las 4 instrucciones de manera consecutiva: SUB R1, R3,R2 ADDI R3,Ⲇ7,R2 LOAD 1(R4), R5 ADDI R5,Ⲇ3,R5

R1= F454 h R2= 0010 h R3= 6100h R4= 0002 h R5= 57BAh

Solución: Suponemos que el programa está almacenado en memoria a partir de la primera posición de memoria: 00h

SUB R1, R3,R2

01h

ADDI R3, Ⲇ7,R2

02h

LOAD 1(R4), R5

03h

ADDI R5,Ⲇ3,R5

A continuación escribimos las operaciones que realizan las instrucciones y el resultado de la misma: 00h

SUB R1, R3,R2

R2pR1-R3

F454h . 6100h % 9354h

01h

ADDI R3, Ⲇ7,R2

R2pR3!7

6100h ! 0007h % 6107h

02h

LOAD 1(R4), R5

R5pM[0003h]

****

03h

ADDI R5,Ⲇ3,R5

R5pR5!3

ED18h ! 0003h % ED1B

**** Exactamente lo que carga es el contenido de la posición de memoria número 3 que corresponde con el código máquina de la instrucción: ADDI R5,Ⲇ3,R5.

Los registros quedarán por tanto: R1 % F454h R2 % 6107h R3 % 6100h R4 % 0002h R5 % ED1Bh PROBLEMA 15 Indica cuál es el resultado de ejecutar las siguientes instrucciones, dando el contenido final de los registros y posiciones de memoria que se modifican y el valor de los indicadores de condición. Se supone para cada caso que el contenido inicial de los registros y posiciones de memoria es el siguiente:

256


R0

0000h

Dirección

Contenido

R1

3201h

00h

1228h

R2

6352h

R3

0001h

01h

36FAh

R4

0002h

02h

AB01h

R5

0003h

03h

1234h

R6

FFFFh

04h

7865h

R7

0000h

05h

45ABh

ADD R1, R4, R5 ADDI R4, Ⲇ8, R6 ASR R1,R5 LOAD 3(R4), R7 STORE R7, 0(R4) ADD R1,R2,R3

Solución: Analizamos las operaciones que se realizan en cada una de las instrucciones y a continuación actualizamos el contenido de los registros y memoria: ADD R1, R4, R5 Esta instrucción realiza la operación R1!R4 y almacena el resultado en R5: R5 p 3201h ! 0002h % 3203h Por lo tanto el contenido de los registros quedará: R0

0000h

R1

3201h

R2

6352h

R3

0001h

R4

0002h

R5

3203h

R6

FFFFh

R7

0000h

ADDI R4, Ⲇ8, R6 Esta instrucción realiza la operación R4!8 y almacena el resultado en R6: R6 p 0002h ! 0008h % 000Ah Por lo tanto el contenido de los registros quedará: R0

0000h

R1

3201h

R2

6352h

R3

0001h

R4

0002h

R5

3203h

R6

000Ah

R7

0000h


257

ASR R1,R5 Esta es una instrucción de desplazamiento. Desplaza el contenido de R1 una posición a la izquierda y almacena el resultado en R5: R5 p A 2454h % 122Ah Y ahora el contenido del registro cambia: R0

0000h

R1

3201h

R2

6352h

R3

0001h

R4

000Ah

R5

122Ah

R6

FFFFh

R7

0000h

LOAD 2(R7), R7 Estamos ahora ante una instrucción de carga que realiza la operación de almacenar en el registro R7 el contenido de la posición de memoria indicado por la suma R7!2. La posición de memoria que contiene el dato será por lo tanto 0002h cuyo contenido según el enunciado es: AB01h. El nuevo estado de los registros será: R0

0000h

R1

3201h

R2

6352h

R3

0001h

R4

000Ah

R5

122Ah

R6

FFFFh

R7

AB01h

STORE R7, 0(R3) La operación de STORE almacena el contenido de un registro en la posición de memoria indicada por el segundo operando, calculando dicha posición de manera análoga a como se calcula en la instrucción LOAD. Por lo tanto debemos escribir el contenido del registro R7 en la posición 0000h ! R3 % 0001h. Con esto el contenido de la memoria después de ejecutar la instrucción será:

258


Dirección

Contenido

00h

1228h

01h

AB01h

02h

AB01h

03h

1234h

04h

7865h

05h

45ABh

ADD R1,R2,R3 La última instrucción es una suma de registros y escribirá en R3 el resultado de la operación R1!R2: R3 p 3201h ! 6352h % 9553h Con lo que el contenido final de los registros quedará: R0

0000h

R1

3201h

R2

6352h

R3

9553h

R4

000Ah

R5

122Ah

R6

FFFFh

R7

AB01h

PROBLEMA 16 Escribir un programa en lenguaje ensamblador que ordene por el método de la burbuja el siguiente vector de 8 elementos: V % [0,3,7,6,2,5,1,4] Solución: El algoritmo de la burbuja es un algoritmo clásico de iniciación a la programación y se puede expresar en pseudocódigo de la siguiente forma: for i%0 to tamaño–vector-1 for j%0 to tamaño–vector-2 if vector(j) b vector (j!1) temp% v(j); v(j)%v(j!1); v(j!1)%temp; end if end for endfor


259

El diagrama de flujo resulta sencillo a partir de este pseudocódigo partiendo por ejemplo del problema 17:

260


.BEGIN

INICIO

V:

.DW 0,3,7,6,2,5,1,4

VSIZE=8 INICIO: ADDI R0,#0,R1;

R1:=i

FORI:

SUBI R1,#VSIZE,R0;

Comparar (i, VSIZE)

BGE FIN;

Salta si i>=VSIZE

ADDI R0,#0,R2; FORJ:

SUBI R2,#VSIZE,R0;

Comparar (i, VSIZE)

BGE ENDFORI;

Salta si i>=VSIZE

LOAD V(R2),R3;

R3:=V[j]

ADDI R2,#1,R4;

R4:=j+1

LOAD V(R4),R5;

R5:=V[j+1]

SUB R5,R3,R0 BL ENDFORJ STORE R5,V(R2); STORE R3,V(R4); ENDFORJ:ADDI R2,#1,R2;

j++

BR FORJ ENDFORI:ADDI R1,#1,R1 BR FORI FIN:

.END

PROBLEMA 17 Escribir un programa en lenguaje ensamblador que intercambie los siguientes dos vectores almacenados en memoria: V % [1,1,1,2]

y

W % [0,0,0,3]

Solución: El algoritmo de intercambio de vectores en pseudocódigo se reduce a un bucle for: for i%0 to tamaño–vector temp% v(i); v(i)%w(i); w(i)%temp; endfor


y el diagrama de flujo quedará, identificando tamaño–vector con VSIZE:

Que se traduce en el siguiente código: .BEGIN

INICIO

V:

.DW 1,1,1,2

W:

.DW 0,0,0,3

VSIZE=4 INICIO:ADDI R0,#0,R1;

R1:=i

FOR:

SUBI R1,#VSIZE,R0;

Comparar (i, VSIZE)

BGE FIN;

Salta si i>=VSIZE

LOAD V(R1),R2;

R2:=V[i]

LOAD W(R1),R3;

R2:=V[i+1]

STORE R2, W(R1); STORE R3, V(R1); ADDI R1,#1,R1; BR FOR FIN:

.END

i!!

261

262


PROBLEMA 18 Escribe en lenguaje ensamblador de la MR un programa que realice la división por 2n de un número NUM. El exponente n es un número positivo menor de 16. Solución: A: dato N for i%0 to N A:%A/2 end for .BEGIN A:

INICIO .DW 256

N%6 INICIO:ADDI R0,#0,R1;

R1:=i

LOAD A(R0),R2;

R2:=A

SUBI R1,#N,R0;

Comparar (i, VSIZE)

BGE FIN;

Salta si i>=VSIZE

ASR R2,R2;

DIVIDE POR 2

ADDI R1,#1,R1;

i++

FOR:

INC:

BR FOR FIN:

STORE R2,A(R0); .END

PROBLEMA 19 Traducir el siguiente pseudocódigo a ensamblador de la MR, suponiendo que los vectores se almacenan a partir de la dirección de memoria 00h y el programa se almacena a partir de la dirección 60h. B % [2,1,2,2,3,9,8,8,7,5]. C % [0,9,8,6,7,6,6,7,8,2] N%10; For i%0 to N-1 If B[i]>C[i] A[i]:=B[i]+C[i] else A[i]:=C[i]-B[i] end if end for


263

Solución: .BEGIN B: C: A: N%10

INICIO .DW 2,1,2,2,3,9,8,8,7,5 .DW 0,9,8,6,7,6,6,7,8,2 .RW 10

INICIO: ADDI R0,#0,R1; FOR: SUBI R1,#N,R0; BGE FIN; LOAD B(R1),R2; LOAD C(R1),R3; SUB R2,R3,R0 BLE ELSE ADD R2,R3,R4 BR INC ELSE: SUB R3,R2,R4 INC: STORE R4,A(R1); ADDI R1,#1,R1 BR FOR FIN: .END

R1:=i Comparar (i, VSIZE) Salta si i>=VSIZE R2:=B[i] R3:=C[i]

PROBLEMA 20 Realizar una macro que realice la operación A/2n y escribir un programa ejemplo que utilice esa macro para n % 6. Solución: La macro la definimos de la siguiente forma: .DEF POT $1,$2 ;$1% REGISTRO FUENTE ;$2% EXPONENTE ADDI R0,#0,R3; FOR: SUB $2,R3,R0; BLE FIN ASR $1,$1; ADDI R3,#1,R3; BR FOR FIN: .ENDDEF

Y el programa será: .BEGIN INICIO VALOR: . .DW 256 EXP: .DW 6

264


RESULT: INICIO:

.RW 1 LOAD VALOR(R0),R1 LOAD EXP(R0),R2 POT R1,R2 STORE R2,RESULT(R0)

.END

Que se traduciría a un programa conjunto como: .BEGIN inicio valor: .DW 256 exp: .DW 6 result: .RW 1 inicio: load valor(R0),R1 load exp(R0),R2 –pot R1,R2

$010101:

addi R0,#0,R3 sub R2,R3,R0 ble $010102 asr R1,R1 addi R3,#1,R3 br $010101

$010102: –end pot R1,R2 store R2,result(R0) .END

6.7 Problemas propuestos PROBLEMA 1 Codificar en el lenguaje de la máquina rudimentaria el siguiente algoritmo: vsize%6; V%[0,1,2,3,4,5]; W%vector vacio de Ⲇvsize elementos; cont%0; repeat If (cont % 1) or (cont b% 3) then W(cont)%V(cont-1); Else W(cont) % Ⲇvsize; Until (cont % 6)


265

PROBLEMA 2 Indica cuál es el resultado de ejecutar las siguientes instrucciones, dando el contenido final de los registros y posiciones de memoria que se modifican y el valor de los indicadores de condición. Se supone para cada caso que el contenido inicial de los registros y posiciones de memoria es el siguiente: R0

0000h

Dirección

Contenido

SUB R1, R4, R5

R1

3201h

00h

1228h

ADDI R4, Ⲇ8, R6

R2

6352h

01h

36FAh

R3

0001h

02h

AB01h

STORE R7, 0(R4)

R4

0002h

03h

1234h

ADD R1,R2,R3

R5

0003h

04h

7865h

R6

FFFFh

05h

45ABh

R7

0000h

ASR R1,R5 LOAD 3(R4), R7

PROBLEMA 3 Codificar en lenguaje ensamblador de la máquina rudimentaria el siguiente programa: IF A b B b C b D THEN F % A ! B ! C !D ELSE A % B; B % C; C % D; D % E; E % A; F % 0 PROBLEMA 4 Diseñar un programa en lenguaje ensamblador que calcule el máximo común divisor de 93, 75, 24 y 13. PROBLEMA 5 Diseñar un programa en lenguaje ensamblador que calcule el mínimo común múltiplo de 93, 75, 24. PROBLEMA 6 Diseñar una macro en lenguaje ensamblador de la máquina rudimentaria que realice el producto de 3 números. PROBLEMA 7 Diseñar un programa en lenguaje ensamblador de la máquina rudimentaria que almacene en una variable el producto de 4 valores utilizando la macro diseñada en el problema propuesto 6.

266


PROBLEMA 8 Diseñar un programa en lenguaje ensamblador que realice el producto de dos matrices de 3 # 3 valores. Defina claramente cómo se almacenarán los valores en memoria. PROBLEMA 9 Codificar el siguiente algoritmo en el lenguaje máquina de la MR. Dibujar también un diagrama de flujo que sirva para la codificación en lenguaje máquina y sea lo más completo posible v % [2 0 8 3 4 6 7 9 1]; w % [1 2 2 2 3 0 8 8 6] {--Algoritmo--} for k%1 to vsize if v(k) a w(k) w(k)%v(K) endif endfor PROBLEMA 10 Implementar el lenguaje ensamblador una macro que realice la operación A*B/8 y escriba un programa que la utilice.

Al diseñar un computador o al mejorar un subsistema de alguno existente, el arquitecto de computadores debe tener presentes los objetivos de la máquina a modificar teniendo en cuenta dos parámetros importantes: el coste y el rendimiento. Dependiendo del equilibrio que se haga de ellos se creará desde un ordenador personal (barato y rendimiento medio) hasta un supercomputador (caro y con un rendimiento muy alto). En este capítulo se tratan los aspectos relacionados con el rendimiento y el coste de un computador. Antes de exponer las principales métricas utilizadas para evaluar el rendimiento de un computador, proporcionamos algunas definiciones útiles.

7.1 Definiciones Todos los computadores utilizan una señal periódica que determina el momento en que tienen lugar los eventos hardware: dicha señal se llama reloj. Tiempo de ciclo: Es el tiempo en segundos que transcurre entre dos tics de reloj. Frecuencia de reloj: Es la inversa del tiempo de ciclo (medido en Hz % s.1) Ciclos de reloj por programa: Instrucciones por programa Ciclos promedio por instrucción Los Ciclos Promedio por Instrucción (CPI) se calculan como una suma ponderada del número de ciclos que tarda por separado cada tipo de instrucción. Ejemplo de ejecución de un programa: Operación

Frecuencia

Ciclos

CPI

% tiempo

Aritméticas

50%

1

0,5

23%

Carga

20%

5

1,0

45%

Almacenamiento

10%

3

0,3

14%

Salto

20%

2

0,4

18%

CPI % 2,2

268


7.2 Medidas de rendimiento Las medidas de rendimiento permiten comparar objetivamente las prestaciones de computadores distintos. Permiten determinar cuál ofrece mayor potencia de cálculo o mayor velocidad de procesamiento, es decir, cuál tarda menos tiempo en ejecutar nuestras aplicaciones. Las principales métricas son las siguientes: Tiempo de ejecución (medido en segundos/programa): Incluye, junto con el tiempo de ejecución de un programa, los tiempos de E/S, tiempos de acceso a memoria, tiempo de sistema operativo, etc. Es útil, pero depende de demasiados factores para poder ser usado eficientemente. Tiempo de CPU: Sólo cuenta la fracción de tiempo de ejecución en la que la CPU está ocupada. Puede ser descompuesto en dos términos: Tiempo de usuario: tiempo empleado por la CPU para ejecutar un programa. Tiempo de sistema: tiempo empleado por la CPU para ejecutar tareas del sistema operativo en beneficio del programa. De los anteriores, consideraremos como métrica principal del rendimiento de un procesador para un programa el tiempo de usuario de CPU. Se define como: (Instrucciones por programa) # CPI # (Tiempo de ciclo) Donde las instrucciones por programa dependen directamente de los programadores, los compiladores y la arquitectura del repertorio de instrucciones. El tiempo de ciclo depende de la tecnología y la organización interna del computador, y los ciclos promedio por instrucción dependen de la organización interna del computador y de la arquitectura del repertorio de instrucciones. El rendimiento se evalúa ejecutando programas reales, programas de prueba (benchmarks) que ejecutan un amplio abanico de operaciones de forma intensiva (operaciones multimedia, en coma flotante, desplazamiento, etc.). Existen además otras métricas muy utilizadas para evaluar el rendimiento. A continuación enumeramos dos de ellas.

7.3 MIPS: Millones de instrucciones por segundo Dado un programa, esta métrica se calcula usando una de las siguientes ecuaciones: MIPS %

Instrucciones por programa Tiempo ejecución # 106

MIPS %

Frecuencia de reloj CPI # 106

MIPS presenta algunas deficiencias: Depende del repertorio de instrucciones: El tiempo que tarda en ejecutarse una misma instrucción y el número de instrucciones máquina que genera el compilador puede variar de un repertorio a otro. Dos programas distintos pueden tener comportamientos opuestos.

Capítulo 7 Rendimiento

269

La medida de MIPS puede variar mucho de un programa a otro: Existen instrucciones que tardan más tiempo en ejecutarse que otras. Los programas en los que abundan instrucciones «rápidas» tardan menos en ejecutarse Los programas en los que abundan instrucciones «lentas» tardan más en ejecutarse. Los fabricantes pueden dar medidas de MIPS muy optimistas: Utilizando programas donde predominan instrucciones que tardan poco en ejecutarse.

7.4 MFLOPS: Millones de instrucciones en coma flotante por segundo Esta métrica evalúa las instrucciones en coma flotante porque son las que más tardan en ejecutarse. Es una medida algo más fiable del rendimiento real del computador, se define como: MFLOPS %

Instrucciones de coma flotante por programa Tiempo ejecución # 106

Al igual que MIPS, MFLOPS presenta algunas deficiencias: Depende del repertorio de instrucciones en coma flotante: No todos los computadores ofrecen las mismas operaciones en coma flotante. Dos programas distintos pueden tener comportamientos opuestos. Es inútil para muchos programas: Los programas enteros (sin operaciones en coma flotante) no pueden medirse en MFLOPS. Existen instrucciones en coma flotante de distinto tiempo de ejecución: Por ejemplo, las operaciones aritméticas como la suma o la resta son rápidas. En cambio algunas operaciones trigonométricas o logarítmicas son lentas. Los fabricantes pueden dar también medidas de MFLOPS optimistas: Al igual que en MILP, utilizando programas donde predominan instrucciones que tardan poco en ejecutarse.

7.5 Ley de AMDAHL La Ley de Amdahl establece que «la mejora obtenida en el rendimiento de un sistema debido a la alteración de uno de sus componentes está limitada por la fracción de tiempo que se utiliza dicho componente». Matemáticamente se puede describir mediante la siguiente ecuación: A%

Tiempo sin mejora % Tiempo con mejora

1 (1 . Fm) !

Fm Am

donde: A: es la aceleración o ganancia en velocidad conseguida en el sistema completo debido a la mejora de uno de sus subsistemas. Am: Factor de mejora que ha introducido el subsistema alterado. Fm: Fracción de tiempo que el sistema emplea el subsistema alterado.

270


7.6 Problemas resueltos PROBLEMA 1 Si la máquina A corre un programa en 10 segundos y la máquina B corre el mismo programa en 15 segundos, ¿cuántas veces es más rápida A que B? Solución: El rendimiento es la inversa del tiempo de ejecución: R%

1 T

Por lo tanto la relación de rendimiento es: RA TB % % 1,5 RB TA Y A es por tanto 1,5 veces más rápida que B. PROBLEMA 2 Se desea comparar el rendimiento de dos máquinas diferentes: M1 y M2. Se han tomado las siguientes medidas: Programa

Tiempo en M1

Tiempo en M2

A

4,0 segundos

3,0 segundos

B

10,0 segundos

20,0 segundos

¿Qué máquina es más rápida para cada programa y en qué medida? Solución: Programa A: Tiempo en M1: 4,0 segundos Tiempo en M2: 3,0 segundos El computador M2 es más rápido para el programa A, de hecho es 4,0/3,0 % 1,33 veces más rápido. Programa B: Tiempo en M1: 10,0 segundos Tiempo en M2: 20,0 segundos Claramente, M1 es más rápido que M2 para el programa B, 20,0/10,0 % 2 veces más rápido.


271

PROBLEMA 3 Considere los dos computadores del problema anterior. Se realizan las siguientes medidas adicionales: Programa

Instrucciones en M1

Instrucciones en M2

A

5 # 109

6 # 109

Determinar el número de instrucciones por segundo para cada computador cuando éstos ejecutan el programa A. Solución: Total de instrucciones ejecutadas en M1: Tiempo de M1: Instrucciones por segundo:

5 # 109 instrucciones. 4,0 segundos 5 # 109/4 % 1,25 # 109 instrucciones/segundo.

Total de instrucciones ejecutadas en M2: Tiempo de M2: Instrucciones por segundo:

6 # 109 instrucciones. 3,0 segundos 6 # 109/3 % 2 # 109 instrucciones/segundo.

PROBLEMA 4 Una empresa está decidiendo comprar un lote de una de las dos máquinas del problema anterior. Supongamos que la máquina M1 cuesta 400 e y que M2 cuesta 700 e. Si el programa A debe ejecutarse un mayor número de veces, ¿qué computador comprarías en grandes cantidades? ¿Por qué? Solución: Coste de M1: Coste de M2:

400 e 700 e

Tiempo del programa A en M1: 4 segundos Tiempo del programa A en M2: 3 segundos En este caso deseamos maximizar el ratio de tiempo de cómputo a la vez que minimizamos el coste requerido para hacerlo, es decir, calculamos el coste por unidad de rendimiento: Coste % Coste # Tiempo de ejecución 1 ejecución programa A Tiempo de ejecución Por lo tanto: Para M1:

400 e # 4 s % 1.600 e s

Para M2:

700 e # 3 s % 2.100 e s

De donde se deduce que M2 sale menos rentable que M1, por lo que M1 es el que debe ser elegido para adquirir el lote.

272


PROBLEMA 5 Un ingeniero está preocupado por el rendimiento de dos computadores, que ejecutando dos programas ofrecen los siguientes resultados. Programa

Tiempo en M1

Tiempo en M2

1

2,0 segundos

1,5 segundos

2

5,0 segundos

10,0 segundos

Si M1 cuesta 500 e y M2 cuesta 800 e. Si los programas 1 y 2 se ejecutan con una frecuencia similar, a) ¿Qué computador ofrece un mejor rendimiento global? ¿En qué medida? b) ¿Qué computador es más efectivo en términos de rentabilidad? Solución: a) Como la carga de ambos programas es similar, podemos trabajar con la suma de tiempos de ambos programas: Tiempo total para M1:

2,0 s ! 5,0 s % 7,0 s

Tiempo total para M2:

1,5 s ! 10,0 s % 11,5 s

Por lo tanto M1 es 11,5 s/7,0 s % 1,64 veces más rápido que M2. b) M1 es claramente más rentable, puesto que es el más barato además del más rápido. PROBLEMA 6 Se quiere ejecutar un programa de 7,5 # 109 instrucciones en una máquina de 5 GHz con un CPI de 0,8. a) ¿Cuál es el tiempo de CPU? b) Cuando se ejecuta el programa, este tarda 3 segundos en acabar, ¿cuál es el tiempo (en porcentaje) tomado por la CPU para ejecutar el programa? Solución: Número de instrucciones:

7,5 # 109

Frecuencia:

5 GHz

CPI:

0,8

a) El tiempo de CPU viene dado por la siguiente ecuación: t%

Instrucciones # CPI % 7,5 # 109 # 0,8 # 0,2 # 109 % 1,2 segundos Frecuencia


273

b) Si el tiempo real de ejecución es de tres segundos, el tiempo invertido en el programa por la CPU será: % tiempo tomado por CPU %

1,2 # 100 % 40% 3

El resto del tiempo (60%) se habrá dedicado a entrada/salida, sistema operativo, etc. PROBLEMA 7 Se dispone de los siguientes datos respecto a dos potentes procesadores y una determinada tarea de aplicación: Power PC a 1,8 GHz de frecuencia y 700 MIPS de potencia. Pentium 4: 1,6 GHz de frecuencia y 850 MIPS. Calcular el CPI de cada procesador. Solución: El número de Ciclos Promedio por Instrucción (CPI) se puede calcular sencillamente usando la expresión: MIPS %

Frecuencia de reloj CPI # 106

á

CPI %

Frecuencia de reloj MIPS # 106

Por lo tanto, en el Power PC: CPI %

Ciclos 1,8 # 109 Ciclos % 2,57 6 700 # 10 Instrucción Instrucción

Mientras que el Pentium 4: CPI %

Ciclos 1,6 # 109 Ciclos % 1,88 6 850 # 10 Instrucción Instrucción

PROBLEMA 8 Se dispone de un computador dotado del procesador Power PC a 1,8 GHz y otro con el Pentium 4 a 1,6 GHz. Se sabe que el CPI del primero es de 5,5 y el del segundo de 7 para un determinado programa escrito en lenguaje de alto nivel. El programa que traduce dicho programa a instrucciones máquina del Power PC lo convierte en nueve millones de dichas instrucciones, mientras el que realiza la misma traducción a instrucciones máquina del Pentium lo convierte en 7,2 # 105 instrucciones. ¿Cuál de los computadores ejecutará más rápidamente la tarea? Solución: El tiempo de ejecución del programa se puede calcular usando: T % NI # CPI # t

274


Donde NI es el número de instrucciones y t es el tiempo de ciclo. Por lo tanto podemos calcular el tiempo de ejecución para ambos computadores. Para el Power PC tenemos: T % NI # CPI # t % 9 # 106 # 5,50 #

1 s % 27,50 ms 1,80 # 109

Mientras que para el Pentium 4 resulta: T % NI # CPI # t % 7,20 # 106 # 7 #

1 s % 31,50 ms 1,60 # 109

PROBLEMA 9 Sea una arquitectura cuyo repertorio de instrucciones está formado por cuatro tipos de instrucciones cuyas medidas de CPI se muestran en la siguiente tabla: Tipo

CPI

Tipo 1

1

Tipo 2

2

Tipo 3

3

Tipo 4

4

Se nos pide que evaluemos dos compiladores diferentes con vista a adquirir uno de ellos para nuestro departamento de desarrollo. Compilando un mismo programa en cada compilador se obtienen los siguientes valores (en miles de millones para cada tipo de instrucción), tal y como se refleja en la tabla siguiente: Compilador

Total de instrucciones por tipo (miles de millones) Tipo 1

Tipo 2

Tipo 3

Tipo 4

Compilador 1

5

1

1

2

Compilador 2

10

1

1

4

Si la frecuencia de reloj de los computadores que tenemos en nuestro departamento de desarrollo es de 1,2 GHz, se pide: a) Ejecutable más rápido en cuanto a tiempo de ejecución. b) Ejecutable más rápido tomando como medida los MIPS. Solución: a) Para averiguar cuál es el ejecutable más rápido basta con calcular el tiempo de ejecución de cada uno de los programas utilizando la fórmula (t % tiempo de ciclo): T % NI # CPI # t


275

Y como: CPI %

Ciclos de reloj NI

La ecuación anterior se reduce a: T % Ciclos de reloj # t Podemos calcular directamente el tiempo de ejecución para el programa resultante de cada compilador: T1 % (5 # 109 # 1 ! 1 # 109 # 2 ! 1 # 109 # 3 ! 2 # 109 # 4)t % 18 # 109t T2 % (10 # 109 # 1 ! 1 # 109 # 2 ! 1 # 109 # 3 ! 4 # 109 # 4)t % 31 # 109t Y por lo tanto, el compilador 1 genera un programa que es 1,72 veces más rápido que el generado por el compilador 2. b) Podemos calcular los MIPS utilizando la fórmula: MIPS %


Por lo tanto, para cada compilador tenemos: MIPS1 %

9 # 109 # 1,2 # 109 % 600 18 # 109 # 106

MIPS2 %

16 # 109 # 1,2 # 109 % 619,4 31 # 109 # 106

Aunque el compilador 1 genera un programa más rápido, el compilador 2 ejecuta más instrucciones por segundo. PROBLEMA 10 Nuestro programa favorito se ejecuta en 10 s. en un computador A que tiene un reloj de 100 MHz. Estamos tratando de ayudar a un diseñador que construye una máquina B, que ejecutará este programa en 6 s. El diseñador ha determinado que es posible un incremento sustancial en la frecuencia de reloj, pero este incremento afectará al resto del diseño de la CPU, haciendo que la máquina B necesite 1,2 veces el número de ciclos de reloj que la máquina A para este programa. ¿Qué frecuencia de reloj debería utilizar el diseñador? Solución: Primero calculamos el número de ciclos de reloj para el programa en A. El tiempo de usuario de CPU es el cociente entre el número de ciclos de un programa y la frecuencia de reloj: TA %

CA FA

276


por lo tanto CA

10 s %

100 . 106

ciclos s

de donde CA % 1.000 # 106 ciclos El tiempo para B se puede hallar mediante la ecuación anterior, teniendo en cuenta que CB % 1,2 # CA: TB %

1,2 # CA á FB

6 s%

1,2 # 1.000 # 106 ciclos FB

de donde finalmente se puede obtener la frecuencia para B: FB %

ciclos 1,2 # 1.000 # 106 ciclos % 200 # 106 % 200 MHz 6s s

PROBLEMA 11 Supongamos que tenemos dos implementaciones de la misma arquitectura del repertorio de instrucciones. La máquina A tiene una duración de ciclo de 10 ns y un CPI de 2,0 para un programa. La máquina B tiene una duración de ciclo de 20 ns y un CPI de 1,2 para el mismo programa. ¿Qué máquina es más rápida para este programa, y cuánto? Solución: Como tienen el mismo repertorio, sabemos que las dos ejecutan el mismo número de instrucciones para el programa, sea Ni. Los ciclos de reloj para cada máquina son: CA % Ni # 2,0 CB % Ni # 1,2 Ahora podemos calcular el tiempo de CPU para cada máquina (t % tiempo de ciclo): TA % CA # tA % Ni # 2,0 # 10 ns % 20 # Ni ns TB % CB # tB % Ni # 1,2 # 20 ns % 24 # Ni ns Claramente, A es más rápida que B. La proporción es: RA TB 24 # Ni ns % % % 1,2 RB TA 20 # Ni ns PROBLEMA 12 Se ha diseñado un procesador multiciclo basado en MIPS con la siguiente clasificación de instrucciones y sus respectivos ciclos de ejecución:


Instrucción

277

Ciclos

Carga

5

Almacenamiento

4


4

Salto condicional, realizando el salto

4

Salto condicional, no realizando el salto

3

Salto incondicional

3

Inicialmente se determinó que la ruta crítica que fija la longitud del ciclo de reloj se corresponde con las operaciones en las unidades aritméticas, y no con los accesos memoria como realmente ocurre. Esto ha llevado a replantear la implementación para que la frecuencia de reloj sea de 500 MHz en vez de 750 MHz inicialmente propuesta. Sin embargo, uno de los ingenieros ha propuesto como solución de compromiso que los ciclos de acceso a memoria se subdividan en dos para, de este modo, admitir la frecuencia de reloj inicial (750 MHz). Usando las proporciones de instrucciones que se muestran a continuación, determina la ganancia de velocidad que se obtiene empleando la máquina de 2 ciclos de acceso a memoria con reloj de 750 MHz, frente a la máquina con 1 ciclo de acceso a memoria y reloj de 500 MHz. Frecuencia de uso de las diferentes instrucciones para un caso típico: Carga: 22%. Almacenamiento: 11%. Aritmético-lógicas: 49%. Salto condicional, realizando el salto: 4%. Salto condicional, no realizando el salto: 12%. Salto incondicional: 2%. Solución: Añadir un ciclo más a la etapa de acceso a memoria implica que las instrucciones de almacenamiento y carga tardarán 5 y 6 ciclos respectivamente en lugar de los 4 y 5 ciclos que tenían destinadas originalmente. En este caso debemos calcular el tiempo de ejecución para cada arquitectura. El tiempo de ejecución viene dado por la siguiente ecuación: T % (instrucciones por programa) # CPI # (tiempo de ciclo) Por lo tanto, en la máquina de 500 MHz T500 MHz % Ni # CPI500 MHz # t500 MHz % Ni # CPI500 MHz #

1 s 500 # 106

278


Mientras que en la máquina de 750 MHz T750 MHz % Ni # CPI750 MHz # t750 MHz % Ni # CPI750 MHz #

1 s 750 # 106

Para calcular los ciclos promedio por instrucción, basta calcular la suma ponderada con los datos del problema. De esta forma, para la máquina a 500 MHz: CPI500 MHz % 0,22 # 5 ! 0,11 # 4 ! 0,49 # 4 ! 0,04 # 4 ! 0,12 # 3 ! 0,02 # 3 % 4,08 Mientras que la máquina de 750 MHz tenemos: CPI750 MHz % 0,22 # 6 ! 0,11 # 5 ! 0,49 # 4 ! 0,04 # 4 ! 0,12 # 3 ! 0,02 # 3 % 4,41 De donde el tiempo de ejecución en ambas máquinas es: 1 s % Ni # 8,16 s 500 # 106 1 s % Ni # 5,87 s T750 MHz % Ni # 4,41 # 750 # 106

T500 MHz % Ni # 4,08 #

Según las ecuaciones anteriores podemos concluir que la máquina original a 750 MHz, incrementando en un ciclo las instrucciones de acceso a memoria, es 1,39 veces más rápida que una máquina con el repertorio original de instrucciones y con el reloj modificado a 500 MHz. PROBLEMA 13 Sea el siguiente juego de instrucciones para un computador, junto a los porcentajes de uso para un determinado programa: Instrucción

Ciclos

Frecuencia

Carga

5

22%

Almacenamiento

4

11%


4

49%

Salto condicional, realizando el salto

4

4%

Salto condicional, no realizando el salto

3

12%

Salto incondicional

3

2%

a) Determinar cuál de las tres máquinas siguientes es la más rápida y con qué relación: M1: ruta multiciclo con los ciclos definidos en la tabla y reloj de 500 MHz. M2: ruta multiciclo en donde las instrucciones de carga y aritmético-lógicas tardan un ciclo menos que en M1. Esto rebaja la frecuencia de reloj a 400 MHz al aumentar la longitud del camino crítico.


279

M3: ruta multiciclo como la de M2 donde además las instrucciones de carga y almacenamiento tardan un ciclo menos que en M2. Esto rebaja la frecuencia de reloj a 250 MHz, al alargar la longitud del ciclo para el camino crítico. b) ¿Hay proporciones de instrucciones que hiciesen que fuese otra la máquina más rápida? Si es así, ¿qué proporciones son esas? Solución: a) Sabemos que el tiempo de ejecución viene dado por la siguiente fórmula: T % Ni # CPI # t Por otro lado, los ciclos por instrucción en cada máquina se resumen en la siguiente tabla: Instrucción

Ciclos M1

Ciclos M2

Ciclos M3

Carga

5

4

3

Almacenamiento

4

4

3

Aritmético-lógica

4

3

3

Salto-condicional (SI)

4

4

4

Salto-condicional (NO)

3

3

3

Salto-incondicional

3

3

3

Junto con los porcentajes dados en los enunciados, podemos obtener el CPI en cada máquina: CPIM1 % 0,22 # 5 ! 0,11 # 4 ! 0,49 # 4 ! 0,04 # 4 ! 0,12 # 3 ! 0,02 # 3 % 4,08 CPIM2 % 0,22 # 4 ! 0,11 # 4 ! 0,49 # 3 ! 0,04 # 4 ! 0,12 # 3 ! 0,02 # 3 % 3,37 CPIM3 % 0,22 # 3 ! 0,11 # 3 ! 0,49 # 3 ! 0,04 # 4 ! 0,12 # 3 ! 0,02 # 3 % 3,04 De donde, el tiempo de ejecución será: TM1 % Ni # 4,08 #

1 s % Ni # 8,16 ns 500 # 106

TM2 % Ni # 3,37 #

1 s % Ni # 8,42 ns 400 # 106

TM3 % Ni # 3,04 #

1 s % Ni # 12,12 ns 250 # 106

Por lo tanto la máquina M1 es 1,03 veces más rápida que M2 y 1,49 veces más rápida que M3.

280


b) Por ejemplo, si el 100% de las instrucciones fuesen aritméticas, el CPI de M1 sería 4 y el de las otras dos máquinas sería 3. En este caso, el tiempo de ejecución es: TM1 % Ni # 4 #

1 s % Ni # 8 ns 500 # 106

TM2 % Ni # 3 #

1 s % Ni # 7,5 ns 400 # 106

TM3 % Ni # 3 #

1 s % Ni # 12 ns 250 # 106

En cuyo caso la máquina M2 sería la más rápida. PROBLEMA 14 Se tiene un programa en un computador X que tarda 35 segundos en ejecutarse mientras que en el computador Y emplea 21 segundos. Se sabe que el programa está formado por 522 millones de instrucciones. ¿Cuánto es más rápido el computador Y que el X? ¿Qué cantidad de instrucciones por segundo (MIPS) ejecuta cada computador? Solución: Se sabe que una máquina Y es n veces más rápida que otra X si: RY TX % %n RX TY Con lo que: TX % 1,67 TY De donde se desprende que el computador Y es 1,67 veces más rápido que el X. Para la segunda cuestión podemos utilizar la fórmula: MIPS %


De donde, para la máquina X tenemos: MIPSX %

522 # 106 instrucciones % 14,91 35 s # 106

Mientras que para la máquina Y: MIPSY %

522 # 106 instrucciones % 24,86 21 s # 106


281

PROBLEMA 15 En un concurso de algoritmos en ensamblador que realizan la misma tarea, el algoritmo que menor tiempo emplee será el ganador. Se supone que el código estará formado por tres tipos de instrucciones únicamente, recogiéndose en la tabla siguiente el número de ciclos por instrucción para cada uno de los tipos Tipo 1

1

Tipo 2

2

Tipo 3

3

Tras un cuidadoso estudio del código de los participantes, el jurado se ha quedado con dos programas cuyas características se muestran en la tabla siguiente: Programa

Total de instrucciones por tipo Tipo 1

Tipo 2

Tipo 3

Programa 1

2

1

2

Programa 2

4

1

1

Se nos pide determinar el programa ganador. Solución: Para averiguar cuál es el programa ganador basta con calcular el tiempo de ejecución de cada uno de los programas utilizando la fórmula (t % tiempo de ciclo): T % Ni # CPI # t Y como: CPI %

Ciclos de reloj Ni

La ecuación anterior se reduce a: T % Ciclos de reloj # t Podemos calcular directamente el tiempo de ejecución para cada programa: T1 % (2 # 1 ! 1 # 2 ! 2 # 3)t % 10t T2 % (4 # 1 ! 1 # 2 ! 1 # 3)t % 9t Y por lo tanto, el programa 2 es el ganador, pues es un 10% más rápido que el programa 1.

282


PROBLEMA 16 Un programa consta de 140 instrucciones de las cuales 70 tardan en ejecutarse cuatro ciclos, 35 tardan cinco ciclos, 20 tardan tres ciclos y las 15 restantes tardan siete ciclos. Calcular el CPI promedio para dicho programa. Si el procesador funciona a una frecuencia de 2,0 GHz, averiguar el tiempo que se tarda en ejecutar el programa. Solución: Para calcular el número de Ciclos Promedio por Instrucción (CPI) realizaremos la suma ponderada de cada tipo de instrucción del programa. En primer lugar debe calcularse la frecuencia relativa de cada tipo, usando la expresión: fi %

ni N

Donde ni es el número de instrucciones del i-ésimo tipo y N es el número total de instrucciones del programa. Finalmente el CPI del programa es la suma ponderada del número de ciclos de cada tipo de instrucción (CPIi): CPI % ; fi # CPIi Teniendo en cuenta las expresiones anteriores puede completarse fácilmente la siguiente tabla: ni

CPIi

fi

fi # CPIi

70

4

0,50

2

35

5

0,25

1,25

20

3

0,14

0,42

15

7

0,11

0,77 CPI % 4,44

El tiempo de ejecucion del programa puede obtenerse usando el CPI calculado previamente: T % Ni # CPI # t De donde T % 140 # 4,44 #

1 s % 3,108 # 10.7 s ] 0,321 ]s 2,0 # 109

PROBLEMA 17 Se desea mejorar el rendimiento de un computador introduciendo una tarjeta gráfica de última generación que realice las operaciones en la mitad de tiempo. a) Calcular la ganancia en velocidad del sistema para la ejecución de un programa si el 87% del mismo se dedica a operaciones gráficas.


283

b) Si el programa tarda 32 segundos en ejecutarse sin la mejora, ¿cuánto tardara con la mejora? Solución: a) La ley de Amdahl se resume en la ecuación: A%


1 (1 . Fm) !

Fm Am

donde: A: es la aceleración o ganancia en velocidad conseguida en el sistema completo debido a la mejora de uno de sus subsistemas. Am: Factor de mejora que ha introducido el subsistema alterado. Fm: Fracción de tiempo que el sistema emplea el subsistema alterado. Para resolver el ejercicio debemos aplicar esta ley de Amdahl. De los datos del enunciado se ve que Am % 2 y que Fm % 0,87 1

A%

(1 . 0,87) !

0,87 2

% 1,7699

De donde vemos que el nuevo sistema será un 76,99% mas rápido. b) A%

Tiempo ejecución sin mejora Tiempo ejecución con mejora

ú

1,7699 %

32 Tiempo ejecución con mejora

De donde el programa, con la mejora tardará 18,08 s en ejecutarse. PROBLEMA 18 Se desea mejorar el repertorio de instrucciones de un computador, y para ello se barajan las alternativas siguientes, todas ellas del mismo coste: Mejorar las instrucciones de suma. Mejorar las instrucciones de salto condicional. Mejorar las instrucciones de carga-almacenamiento. Mejorar el resto de las instrucciones. En la tabla siguiente se recoge el porcentaje de veces que se emplean las instrucciones una vez pasadas las SPECint2006 y el factor de mejora que se puede introducir para cada una de ellas

284


Tipo de instrucción

Porcentaje de uso

Factor de mejora

Suma

30%

10

Salto condicional

55%

2

Carga-almacenamiento

12%

8

Resto de instrucciones

3%

10

Se pide: a) Indicar cuál de las mejoras anteriores es la que recomendaramos. b) Si un programa tardaba antes de la mejora 37,02 s en ejecutarse, calcule cuánto tardará con la mejora que hemos elegido en a). Solución: a) Aplicando la ley de Amdahl para cada uno de los casos se obtiene: Tipo de instrucción

Fm

Am

A

Suma

30%

10

1,37

Salto condicional

55%

2

1,38


12%

8

1,12

3%

10

1,03

Otras

Por lo que la mayor ganancia se da en las instrucciones de salto condicional. b) De la ley de Amdahl sabemos que: A%


ú

1,38 %

37,02 Tiempo ejecución con mejora

Por lo que el tiempo modificando las instrucciones de salto condicional será de 26,83 s. PROBLEMA 19 Se desea mejorar el repertorio de instrucciones de un computador, y para ello se barajan las alternativas siguientes, todas ellas del mismo coste: Mejorar las instrucciones de suma. Mejorar las instrucciones de salto condicional. Mejorar las instrucciones de carga-almacenamiento. Mejorar el resto de las instrucciones.


285

En la tabla siguiente se recoge el porcentaje de veces que se emplean las instrucciones una vez pasadas las SPECint2006 y el factor de mejora que se puede introducir para cada una de ellas. Tipo de instrucción

Porcentaje de uso

Factor de mejora

Suma

30%

1

Salto condicional

34%

4


32%

2

Resto de instrucciones

4%

7

Se pide: a) Indicar cuál de las mejoras anteriores es la que recomendaríamos. b) Si un programa tardaba antes de la mejora 28,3 s en ejecutarse, calcule cuánto tardará con la mejora que hemos elegido en el apartado anterior. Solución: a) Aplicando la ley de Amdahl para cada uno de los casos se obtiene: Tipo de instrucción

Fm

Am

A

Suma

30%

5

1,31

Salto condicional

34%

4

1,34


32%

2

1,19

4%

7

1,03

Otras

Por lo que la mayor ganancia se da en las instrucciones de salto condicional. b) De la ley de Amdahl sabemos que: A%


ú

1,34 %

28,3 Tiempo ejecución con mejora

Por lo que el tiempo modificando las instrucciones de salto condicional será de 22,12 s. PROBLEMA 20 Un computador tiene un rendimiento de 3 MFLOPS normalizados a operaciones sencillas en coma flotante. Si la operación de multiplicación equivale a cuatro operaciones en coma flotante sencillas y la de exponenciación se equipara con 8: a) Calcular el tiempo que se tarda en realizar la tarea sabiendo que consta de las siguientes operaciones en coma flotante: 4.000 sumas, 1.500 multiplicaciones y 2.200 operaciones de de exponenciación.

286


Para el computador anterior se ofrecen tres alternativas de diseño de igual coste: 1. 2. 3.

Introducir una nueva ALU que realiza la operación de exponenciación en 5 ciclos. Introducir una nueva ALU que realiza la operación de multiplicación en 1 ciclo. Introducir algunas mejoras estructurales que permitan aumentar la frecuencia de reloj del procesador de forma que su rendimiento sea 3,5 MFLOPS.

b) Analizar la rentabilidad de estas alternativas. Solución: a) En primer lugar transformamos las operaciones del enunciado a operaciones en coma flotante sencillas. Esto nos dará el número total de instrucciones: Ni % 4.000 ! 4 # 1.500 ! 8 # 2.200 % 27.600 De la fórmula de cálculo de MFLOPS: MFLOPS %

Instrucciones de punto flotante por programa Tiempo ejecución # 106

Se desprende que: Tiempo ejecución %

27.600 Ni s % 9,2 ms 6% MFLOPS # 10 3 # 106

b) La rentabilidad de estas alternativas se puede evaluar mediante la ley de Amdahl: A%


1 (1 . Fm) !

Fm Am

donde: A: es la aceleración o ganancia en velocidad conseguida en el sistema completo debido a la mejora de uno de sus subsistemas. Am: Factor de mejora que ha introducido el subsistema alterado. Fm: Fracción de tiempo que el sistema emplea el subsistema alterado. Caso b.1) En este caso mejoramos las operaciones de exponenciación, reduciéndolas a 5 ciclos. 8 El factor de mejora es Am % % 1,60. 5 El tiempo que el sistema original utiliza estas operaciones se puede deducir con una regla de tres: 4.000 ! 4 # 1.500 ! 8 # 2.200 r 100% 8 # 2.200 r Fm De donde Fm % 63,77%.


287

Y por lo tanto A%

1 0,64 (1 . 0,64) ! 1,60

% 1,32

Finalmente, podemos calcular el tiempo tras la mejora: A%


ú

1,32 %

9,2 ms Tiempo ejecución con mejora

Por lo que el tiempo modificando las instrucciones de exponenciación será de 7 ms aproximadamente. Caso b.2) En este caso mejoramos las operaciones de multiplicación, reduciéndolas a 1 ciclo. 4 El factor de mejora es Am % % 4. 1 El tiempo que el sistema original utiliza estas operaciones se puede deducir con una regla de tres: 4.000 ! 4 # 1.500 ! 8 # 2.200 r 100% 4 # 1.500 r Fm De donde Fm % 21,74%. Y por lo tanto A%

1 0,22 (1 . 0,22) ! 4

% 1,20



ú

1,20 %


Por lo que el tiempo modificando las instrucciones de multiplicación será de 7,7 ms aproximadamente. Caso b.3) En este caso mejoramos todo el sistema, haciendo que éste trabaje a 3,5 MFLOPS. El factor de mejora es Am %

3,5 % 1,17. 3

El tiempo utilizado por el subsistema es en este caso del 100%, de donde Fm % 100%.

288


Y por lo tanto 1

A%

(1 . 1) !

1 1,17

% 1,17



ú

1,17 %


Por lo que el tiempo modificando la frecuencia de reloj será de 7,9 ms aproximadamente. Evidentemente, la mejora en las operaciones de exponenciación (b.1) será la más rentable (sin tener en cuenta factores de coste de implementación.) PROBLEMA 21 Se desea mejorar el rendimiento de un computador introduciendo un coprocesador matemático que realice las operaciones en la mitad de tiempo. a) Calcular la ganancia en velocidad del sistema para la ejecución de un programa si el 96% del mismo se dedica a operaciones aritméticas. b) Si el programa tarda 15 segundos en ejecutarse sin la mejora, ¿cuánto tardará con la mejora? Solución: a) La ley de Amdahl se resume en la ecuación: A%


1 (1 . Fm) !

Fm Am

donde: A: es la aceleración o ganancia en velocidad conseguida en el sistema completo debido a la mejora de uno de sus subsistemas. Am: Factor de mejora que ha introducido el subsistema alterado. Fm: Fracción de tiempo que el sistema emplea el subsistema alterado. Para resolver el ejercicio debemos aplicar esta ley de Amdahl. De los datos del enunciado se ve que Am % 2 y que Fm % 0,96 A%

1 (1 . 0,96) %

0,96 2

% 1,9231

De donde vemos que el nuevo sistema será un 92,31% más rápido.


289

b) A%


ú

1,9231 %

15 Tiempo ejecución con mejora

De donde el programa con la mejora tardará 7,8 s en ejecutarse.

7.7 Problemas propuestos PROBLEMA 1 Sean dos máquinas que arrojan los siguientes datos cuando se ejecutan dos programas en ellas: Programa

Tiempo en M1

Tiempo en M2

P1

2,0 segundos

1,5 segundos

P2

5,0 segundos

10,0 segundos

P1 debe ejecutarse 1.600 veces cada hora. El tiempo restante se emplea en ejecutar P2. Si cada máquina tiene suficiente capacidad como para ejecutar P1 el número de veces requerido, esto significa que el rendimiento viene dado por el número de veces que puede ejecutarse P2. ¿Qué máquina es más rápida dada esta carga de trabajo? ¿Cuál de ellas es más rentable? PROBLEMA 2 Consideremos dos implementaciones diferentes de un programa: P1 y P2, bajo el mismo repertorio de instrucciones que contiene cinco clases de instrucciones (A, B, C, D y E). P1 trabaja en un computador a una frecuencia de 4 GHz, P2 en uno de 6 GHz. Los ciclos promedio por instrucción para P1 y P2 se dan en la siguiente tabla: Clase

CPI en P1

CPI en P2

A

1

2

B

2

2

C

3

2

D

4

4

E

5

4

a) El pico de rendimiento se alcanza cuando el programa está compuesto sólo por las instrucciones más rápidas. ¿Cuál es el pico de rendimiento para P1 y P2? b) Si el número de instrucciones ejecutadas en un programa dado se divide equitativamente entre las instrucciones dadas excepto por las de tipo A, que aparecen el doble de veces, ¿cuánto más rápido es P2?

290


PROBLEMA 3 Sean dos implementaciones distintas de un programa P1 y P2, desarrollados en computadores diferentes pero con el mismo repertorio de instrucciones. Existen tres clases de instrucciones (A, B y C). P1 se ejecuta en un computador a 6 GHz, y P2 en un computador a 3 GHz. Los ciclos promedio para cada clase de instrucción en P1 y P2 vienen dados en la siguiente tabla, así como la proporción de instrucciones generadas por tres compiladores diferentes: Clase

CPI en P1

CPI en P2 Uso de C1 Uso de C2 Uso de C3

A

2

1

40%

40%

50%

B

3

2

40%

20%

25%

C

5

2

20%

40%

25%

Suponga que cada compilador genera el mismo número de instrucciones para ambos programas. a) Usando C1 para compilar P1 y P2, ¿qué programa se ejecuta más rápido y en qué medida? b) Repita el apartado anterior, pero usando C2. c)

Si el programa que usa es P1, ¿qué compilador utilizaría?

d) Repite el apartado anterior para P2 e)

¿Qué programa y compilador utilizaría suponiendo que el coste es el mismo? Recuerde que P1 sólo se puede ejecutar en el computador de 6 GHz y P2 en el de 3 GHz.

PROBLEMA 4 Sea un programa, que se ejecuta en 10 s en un computador a 1 GHz. Se crea una nueva versión del programa, reemplazando todas las multiplicaciones por 4 (x % 4*x) con dos instrucciones que suma la variable a sí misma (x % x ! x; x % x ! x). El CPI de la multiplicación por 4 es 4, mientras que el CPI de la suma es 1. Después de compilar la nueva versión, el programa se ejecuta en 9 s. ¿Cuántas multiplicaciones por 4 se han sustituido por sumas? PROBLEMA 5 Una compañía quiere mejorar un programa Java añadiendo soporte hardware para el recolector de basura. La recolección de basura toma el 20% de los ciclos totales de un programa. Existen dos alternativas para mejorar el computador. La primera solución consiste en recolectar la basura completamente vía hardware. Esto produce un incremento del tiempo de ciclo en un factor de 1,2. La segunda alternativa consiste en proporcionar nuevas y mejores instrucciones para recolectar los punteros no referenciados, lo que reduce a la mitad el tiempo que necesita el recolector original pero incrementa el tiempo de ciclo en un factor de 1,1. ¿Cuál de estas opciones deberíamos tomar? PROBLEMA 6 Supongamos que mejoramos un computador para hacer que todas las operaciones en coma flotante se ejecuten 5 veces más rápido. Si el tiempo de ejecución de un benchmark antes de


291

la mejora del hardware es de 10 s., ¿cuál es la mejora si la mitad del tiempo se emplea en ejecutar operaciones en coma flotante? PROBLEMA 7 Queremos implementar una nueva unidad en coma flotante para un procesador, y queremos que el benchmark elegido para realizar las pruebas mejore el rendimiento en un factor de 3,0. Utilizando nuestra vieja unidad de operaciones en coma flotante el benchmark se ejecuta en 100 s. ¿Cuánto mejorara el tiempo de ejecución del benchmark nuestra nueva unidad funcional? PROBLEMA 8 Queremos mejorar un computador, y tenemos dos posibles alternativas. La primera es hacer que las instrucciones de multiplicación se ejecuten cuatro veces más rápido. La segunda es que las instrucciones de acceso a memoria se ejecuten dos veces más rápido. Ejecutamos repetidas veces un programa que tarda 100 s en ejecutarse. De este tiempo, el 20% se invierte en multiplicación, el 50% en instrucciones de acceso a memoria y el 30% para otras instrucciones. a) ¿Cuál será la ganancia si sólo mejoramos la multiplicación? b) ¿Cuál será la ganancia si sólo mejoramos los accesos a memoria? c) ¿Cuál será la ganancia si mejoramos las dos opciones? PROBLEMA 9 Se desea mejorar el rendimiento de un computador introduciendo un coprocesador matemático que realice las operaciones en coma flotante en la mitad de tiempo. a) Calcular la ganancia en velocidad del sistema para la ejecución de un programa si el 36% del mismo se dedica a operaciones en coma flotante. b) Si el programa tarda 15 segundos en ejecutarse sin la mejora, ¿cuánto tardará con la mejora? PROBLEMA 10 En el dominio de los sistemas empotrados, donde el coste es crucial, a menudo los procesadores implementan sus operaciones en coma flotante vía software. Estamos interesados en dos diseños de un computador, uno con hardware para operaciones en coma flotante y otro sin él. Consideremos un programa con el siguiente juego de instrucciones en coma flotante: – Multiplicación en CF:

10%

– Suma en CF:

15%

– División en CF: – Instrucciones enteras:

5% 70%

El computador CCF (computador con coma flotante) tiene hardware para realizar operaciones en coma flotante. Los ciclos requeridos para cada tipo de instrucciones son los siguientes:

292


– Multiplicación en CF:

6

– Suma en CF:

4

– División en CF: – Instrucciones enteras:

20 2

El computador CSCF (sin coma flotante) debe emular las operaciones en coma flotante usando instrucciones de tipo entero. Una instrucción de tipo entero consume dos ciclos de reloj. Los números de instrucciones enteras requeridos para emular las operaciones en coma flotante son las siguientes: – Multiplicación en CF:

60

– Suma en CF:

20

– División en CF:

50

Calcular la métrica MIPS para ambos computadores.

Los modos de direccionamiento son procedimientos que permiten determinar la dirección de un objeto, siendo un objeto cualquier elemento direccionable, es decir, una instrucción, un operando o un resultado. Se define dirección efectiva como la dirección en la que se encuentra el objeto. Los objetos pueden residir en la propia instrucción, en un registro o en la memoria principal. Los modos de direccionamiento sirven para ahorrar espacio de memoria. Por ejemplo, si un bus de direcciones tiene 64 bits, para direccionar un objeto necesitamos 64 bits, si la instrucción utiliza 2 operandos fuente y un operando destino, necesitará tener un tamaño de más de 192 bits puesto que una instrucción debe incluir mas información aparte de la dirección de los operandos. Si implementamos un modo de direccionamiento que sólo utilice 32 bits se consiguen instrucciones de menor tamaño. Cuanto menor sea el tamaño de las instrucciones, menor es la memoria. Por otro lado, su uso simplifica el manejo de las estructuras de datos complejas, dan flexibilidad a los programadores de lenguaje máquina y facilitan el diseño de compiladores. De las diferentes clasificaciones que existen vamos a usar la siguiente: Inmediato. Directo. Relativo o con desplazamiento. Indirecto.

8.1 Direccionamiento inmediato En este modo de direccionamiento el operando se incluye en la propia instrucción. Este modo se utiliza para definir constantes. Para representar el inmediato se utilizan un número de bits

294


menor que el del bus de datos, por eso cuando se carga en un registro del procesador hay que realizar una operación de extensión de signo. Esta operación consiste en añadir al número inmediato tantos bits como necesite para que alcance el mismo tamaño que el registro destino conservando el mismo valor numérico que representaba antes de la operación. Su principal ventaja es que no se tiene que acceder a memoria para obtener el dato, luego es muy rápido. Su principal desventaja es que la magnitud del dato está restringida por el tamaño del campo inmediato.

8.2 Direccionamiento directo Es aquel modo en el que la instrucción contiene la dirección efectiva del objeto. Se clasifican en: Directo de registro. Directo de memoria. De página base. Directo de registro. La instrucción contiene la dirección de un registro del banco de registros.

De memoria. La instrucción contiene una dirección completa de memoria. Su inconveniente es que el tamaño de la memoria está limitado por el número de bits asignado al campo dirección. Como ventaja tiene su facilidad de implementación. En ocasiones también se le llama absoluto.

Capítulo 8 Modos de direccionamiento

295

De página base. La información contenida es una dirección limitada, que permite acceder sólo a una parte del mapa de memoria. Es decir, tiene menos bits de los necesarios para direccionar toda la memoria. La principal ventaja que tiene es que se reduce el tamaño de la instrucción, luego consume menos bits de memoria. Su principal desventaja es que no puede acceder a todas las posiciones de la memoria. Por último sus tiempos de acceso son similares a los anteriores.

8.3 Direccionamiento relativo En este modo de direccionamiento la instrucción no contiene la dirección del objeto, sino un desplazamiento que se suma al contenido de un registro base para obtener la dirección efectiva. Su ventaja es que el desplazamiento necesita menos bits para realizar el direccionamiento que el directo a memoria. Una característica importante de la implementación es que la suma no debe producir demasiado retardo en el cálculo de la dirección efectiva. Una desventaja es que necesita más hardware para implementarse y es más lento que el directo, puesto que previamente hay que acceder al registro base y realizar la suma. Es muy interesante para tratar códigos reubicables y para recorrer de forma eficaz estructuras de datos. Se pueden encontrar los siguientes casos: Relativo a contador de programa (PC). Relativo a registro base. Relativo a índice. Relativo a pila. Direccionamiento relativo a contador de programa. En este modo de direccionamiento el registro base empleado es el contador de programa PC. Explota el concepto de localidad y por lo tanto es indicado para alcanzar instrucciones próximas a la que se está ejecutando. Se suele utilizar en instrucciones de bifurcación. Tiene la ventaja, frente otros direccionamientos relativos, de no necesitar incluir la dirección del contador de programa en la instrucción puesto que sólo hay uno. La dirección efectiva se consigue sumando el contenido del PC y el campo desplazamiento del registro de instrucciones. Como probablemente no tengan el mismo tamaño, habrá que utilizar un módulo extensión de signo para implementarlo.

296


Direccionamiento relativo a registro base. Se caracteriza porque la instrucción contiene dos informaciones: la dirección del registro base y un desplazamiento que suele tener un tamaño inferior al de una dirección de memoria. El registro base contiene una dirección de memoria. Se utiliza cuando la dirección base no es conocida en tiempo de compilación (la información que se conoce en tiempo de compilación es la información que conoce el programador mientras escribe el programa) pero el desplazamiento relativo sí que lo es.

Direccionamiento relativo a índice. También llamado indexado. Es una modificación del anterior y por lo tanto la instrucción debe contener dos informaciones: la dirección del registro índice que contiene el desplazamiento (atención, darse cuenta que es lo contrario de lo que ocurría en el indexado a registro base) y la dirección base de la memoria que debe estar referenciada con todos los bits. Es decir se consume muchos bits, puesto que la dirección de memoria es grande. Esta es la principal diferencia con el relativo a registro base. Si el n.o bits de desplazamiento del modo relativo a registro base y los de memoria del modo relativo a registro índice coinciden, estos modos son indistinguibles. En ocasiones los direccionamientos relativos se implementan con incrementos y decrementos automáticos del contenido del registro para facilitar el manejo de las estructuras de datos. Esto complica el hardware, pero acorta los programas. Los más habituales son: Preautoincremento. Preautodecremento.


297

Postautoincremento. Postautodecremento. Se suele utilizar cuando se puede conocer la posición de un vector en tiempo de compilación, pero el elemento exacto al que queremos acceder no se conoce nada más que en tiempo de ejecución. Direccionamiento directo relativo a pila. Llamado también direccionamiento a pila. Recordar que una pila es una cola del tipo primero en entrar último en salir. La máquina debe disponer de un registro SP (puntero a pila). Los accesos a pila deben tener un tratamiento especial. Para insertar un elemento en la pila, el direccionamiento relativo a SP debe generar un preautoincremento, y para sacar un elemento de la pila el direccionamiento relativo a SP debe realizar un post-autodecremento. Permite instrucciones muy compactas y si sólo se dispone de un SP la instrucción no necesita información de dirección.

A continuación se ve una posible implementación del HW necesario para modificar el puntero:

298


8.4 Direccionamiento indirecto La dirección contenida en la instrucción NO es la del objeto, sino la de la dirección del objeto. Existen dos tipos: indirecta de memoria e indirecta de registros

En ambos casos es necesario un acceso adicional para obtener el objeto. En el indirecto a memoria se accede dos veces a la memoria, la primera vez para obtener la dirección efectiva del objeto y la segunda para obtener el objeto. No se suele utilizar la indirección multinivel porque retardaría en exceso la ejecución de los programas. El indirecto a registro se utiliza muy a menudo por ser casi el doble de rápido que el indirecto a memoria, puesto que el acceso a registro es mucho más rápido que el acceso a memoria. Es útil cuando la dirección de una estructura de datos sólo se conoce en tiempo de ejecución. Se puede encontrar con autoincremento y autodecrementos. Nota: El pseudo-ensablador para los modos de direccionamiento que se va a usar en los problemas es el siguiente.


Modo de direccionamiento

Pseudo-ensamblador

Inmediato

299

Cálculo de @efectiva

ⲆNumero

Directo a registro

Ri

Directo a memoria

@M

@M

Directo a pila SP

SP

aSPb

Indirecto a registro

(Ri)

aRib

Indirecto a memoria

(@M)

a@Mb

Relativo a contador de programa

Ⲇdesp(PC)

aPCb ! desp

Relativo a registro base

Ⲇdespl(RB)

aRBb ! desp % @M ! desp

Relativo a registro índice

@M(RI)

@M ! aRib % @M ! desp

Los direccionamientos directo a pila, relativo a registro base, relativo a registro índice e indirecto a registro e indirecto a memoria pueden usar además post-incremento (RB)!, postdecremento (RB)., pre-decremento .(RB) y pre-incremento !(RB).

8.5 Problemas resueltos PROBLEMA 1 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 60; aR4b % 5; aR5b % 765; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 65, a@201b % 424, a@202b % 87, a@203b % 53, a@204b % 765, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) ADD R3,R5,R4 b) SUB R3,R5,R4 Sabiendo que el primer operando de las operaciones es el destino. Nota: aRib es el contenido del registro Ri y a@ib es el contenido de la posición i de memoria.

300


Solución: a) ADD R3,R5,R4 usa para los tres operandos direccionamiento directo a registro: R5 r operando1 % 765 R4 r operando2 % 5 R3 r resultado % aR3b % 765 ! 5 % 770 b) SUB R3,R5,R4 usa para los tres operandos direccionamiento directo: R5 r operando1 % 765 R4 r operando2 % 5 R3 r resultado % aR3b % 765 . 5 % 760 PROBLEMA 2 Sabiendo que el banco de registros contiene los siguientes datos: aR0b%0; aR1b%100; aR2b%89; aR3b%60; aR4b%5; aR5b%765; aR6b%676; aR7b%837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 65, a@201b % 424, a@202b % 87, a@203b % 53, a@204b % 765, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguiente instrucción: SUB R3,R4,Ⲇ45 Sabiendo que el primer operando de las operaciones es el destino Nota: aRib es el contenido del registro Ri y a@ib es el contenido de la posición i de memoria. Solución: SUB R3,R4,Ⲇ45 usa para los dos operandos direccionamiento directo a registro y un operando inmediato. R4 r operando1 % 5 Ⲇ45 r operando2 % 45 R3 r resultado % aR3b % 5 . 45 % .40 PROBLEMA 3 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 60; aR4b % 5; aR5b % 765, aR6b % 676; aR7b % 837


301

Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 65, a@201b % 424, a@202b % 87, a@203b % 53, a@204b % 765, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) SUB R7,@200,R3 b) MUL @202,@203,@204 Sabiendo que el primer operando de las operaciones es el destino. Solución: a) SUB R7,@200,R3. Esta instrucción usa dos modos de direccionamiento: directo a registro para el destino y segundo operando, y directo a memoria para el segundo operando: @200 r @efectiva % @200 r operando1 % a@200b % 65 R3 r operando2 % aR3b % 60 R7 r resultado % aR7b % 65 . 60 % 5 b) MUL @202,@203,@204. Usa el modo de direccionamiento directo a memoria para referenciar sus tres operandos. @203 r @efectiva % @203 r operando1%a@203b % 53 @204 r @efectiva % @204 r operando2 % a@204b % 765 @202 r @efectiva resultado % @2002 r resultado % a@202b % 53X765 % % 40545 PROBLEMA 4 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 203 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53

302


Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) ADD R3,R5,(R4) b) SUB R3,(R4),(R5) Sabiendo que el primer operando de las operaciones es el destino. Solución: a) ADD R3,R5,(R4). Esta instrucción usa dos modos de direccionamiento el directo a registro y el indirecto a registro. R5 r operando1 % aR5b % 27 (R4) r @efectiva % aR4b % @25 r operando2 % a@25b % 87 R3 r resultado % aR3b % 27 ! 87 % 114 b) SUB R3,(R4),(R5). Esta instrucción usa dos modos de direccionamiento: directo a registro e indirecto a registro: (R4) r @efectiva % aR4b % @25 r operando1 % a@25b % 87 (R5) r @efectiva % aR5b % @27 r operando 2 % a@27b % 75 R3 r resultado % aR3b % 87 . 75 % 12 PROBLEMA 5 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 203 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) SUB R7,(@200),(R3) b) MUL (@202),(@203),(@204) Solución: a) SUB R7,(@200),(R3). Usa tres modos de direccionamiento: directo a registro, indirecto a memoria e indirecto a registro. (@200) r @efectiva % a@200b % @29 r operando1 % a@29b % 63 (R3) r @efectiva % aR3b % @29 r operando2 % a@29b % 63 R7 r resultado % aR7b % 0


303

b) MUL (@202),(@203),(@204). Esta instrucción usa tres modos de direccionamiento indirecto a memoria. (@203) r @efectiva % a@203b % @30 r operando1 % a@30b % 203 (@204) r @efectiva % a@204b % @27 r operando2 % a@27b % 75 (@202) r @efectiva resultado % a@202b % @28 r resultado % a@28b % % 75 # 203 % 15225 PROBLEMA 6 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) ADD R3,R5,(R4)! b) SUB R3,(R4),(R5) Sabiendo que el primer operando de las operaciones es el destino. Solución: a) ADD R3,R5,(R4)!. Esta instrucción utiliza dos modos de direccionamiento: directo a registro para el primer operando y el destino, e indirecto a registro con post incremento para el segundo operando. R5 r operando1 % aR5b % 27 (R4) ! r @efectiva % aR4b % @25 r operando2 a@25b % 87. Valor final de R4 es aR4b % @26 R3 p resultado % aR3b % 27 ! 87 % 114 b) SUB R3,(R4),(R5). Usa dos modos de direccionamiento: directo a registro para el destino e indirecto a registro para los operandos: (R4) r @efectiva % aR4b % @25 r operando 1 % a@25b % 87 (R5) r @efectiva % aR5b % @27 r operando 2 % a@27b % 75 R3 r resultado % aR3b % 87 ! 75 % 162

304


PROBLEMA 7 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de la siguiente instrucción: SUB R7,(@200),(R3) Sabiendo que el primer operando de las operaciones es el destino. Solución: SUB R7,(@200),(R3) Usa tres modos de direccionamiento diferentes: directo a registro para el destino, indirecto a memoria para el primer operando e indirecto a registro para el segundo operando: (@200) r @efectiva % a@200b % @29 r operando 1 % a@29b % 63 (R3) r @efectiva % aR3b % @29 r operando 2 r a@29b % 63 R7 r resultado % aR7b % 63 . 63 % 0 PROBLEMA 8 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de la siguiente instrucción: MUL -(@202),(@203),(@204) Sabiendo que el primer operando de las operaciones es el destino.


305

Solución: MUL -(@202),(@203),(@204) Usa dos modos de direccionamiento diferentes: indirecto a memoria con pre decremento para el destino e indirecto a memoria para los dos operandos: (@203) r @efectiva % a@203b % @30 r operando1 % a@30b % 654 (@204) r @efectiva % a@204b%@27 r operando2 % a@27b % 75 -(@202) r @efectiva resultado % a@202b-1%@28-1 r Resultado % a@27b% % 49050. El valor final @202 es a@202b%@27 PROBLEMA 9 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@57b % 65 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) ADD !Ⲇ20(R3),Ⲇ30(R5),Ⲇ45 b) ADD Ⲇ20(R3)-,Ⲇ30(R5)!,Ⲇ45 Solución: a) ADD !Ⲇ20(R3),Ⲇ30(R5),Ⲇ45 Tiene tres modos de direccionamiento: relativo a registro base con pre-incremento para el destino, relativo a registro base para el primer operando e inmediato para el segundo operando. Ⲇ30(R5) r @efectiva%aR5b!30%27!30%57 r operando1 % a@57b%65 Ⲇ45 r operando2 % 45 !Ⲇ20(R3) r @efectiva resultado % aR3b ! 20 ! 1 % 29 ! 20 ! 1 % 50 r r resultado % a@50b % 65 ! 45 % 110. El valor final de R3 es aR3b % 30 b) ADD Ⲇ20(R3)-, Ⲇ30(R5)!, Ⲇ45 Tres modos de direccionamiento relativo a registro base con post decremento para el destino, relativo a registro base con post incremento para el primer operando e inmediato para el segundo operando. Ⲇ30(R5)!r @efectiva%aR5b!30%27!30%@57 r operando1%a@57b % % 65. Valor final de R5 es aR5b % 28 Ⲇ45 r operando2 % 45 Ⲇ20(R3)- r @efectiva del resultado % aR3b ! 29 % 29 ! 20 % % @49 r resultado % a@49b%65!45%100. Valor final de R3 es aR3b % 28.

306


PROBLEMA 10 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20 a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) SUB @25(R3),!(R4),(R5)! b) SUB !@25(R3),(R4)-,-(R5) Solución: a) SUB @25(R3),!(R4),(R5)! Tiene 3 modos de direccionamiento: relativo a registro índice para el destino, indirecto a registro con pre incremento para el primer operando, indirecto a registro con post incremento para el segundo operando. !(R4) r @efectiva % aR4b ! 1%25 ! 1%@26 r operando1 % a@26b%986. El valor final del registro R4 es aR4b % 26 (R5) ! r @efectiva % aR5b % 27 r operando2 % a@27b % 75. El valor final del R5 es aR5b % 28 @25(R3) r @efectiva del resultado % aR3b ! 25 % 29 ! 25 % % @54 r resultado % a@54b % 20 b) SUB !@25(R3),(R4)-,-(R5) Tres modos de direccionamiento: relativo a registro índice con pre incremento para el destino, relativo a registro base con post decremento para el primer operando y relativo a registro base con pre decremento para el segundo operando (R4) . r @efectiva % aR4b % @25 r operando1 % a@25b % 87. El valor final de R4 es 23 -(R5) r @efectiva % aR5b . 1 % 27 . 1 % @26 r operando2 % a@26b%986. El valor final del registro R5 es 26 !@25(R3) r @efectiva del resultado % aR3b ! 25 ! 1 % 25 ! 29 ! 1%@55 r r resultado%a@55b%87 . 986 % .899. El contenido final del registro R3 es 30. PROBLEMA 11 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837; aPCb % 100


307

Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20 a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Cuál es la dirección a la que saltan las instrucciones: a) BIF INCONDICIONAL @25 b) BIF INCONDICIONAL (@25) c)

BIF INCONDICIONAL (R7)

Solución: a) BIF INCONDICIONAL @25 @25 r @efectiva salto % @25 b) BIF INCONDICIONAL (@25) (@25) r @efectiva salto % a@25b % @87 c)

BIF INCONDICIONAL (R7) (R7) r @efectiva de salto % aR7b % @837

PROBLEMA 12 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 202; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837; aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 204, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20 a@201b % 424, a@202b % 75, a@203b % 30, a@204b % 75, a@205b % 7 Indicar para la secuencia de instrucciones propuestas, si salta o no salta la instrucción y cuál es @efectiva de salto. SUB R5, (@27)!,Ⲇ0(R1) BIF SI CERO R5,Ⲇ50(PC)

308


Solución: 䊏 SUB R5, (@27)!, Ⲇ0(R1) (@27) ! r @efectiva % a@27b % @204 r operando1 % a@204b % 75. El valor final de @27 es 205. Ⲇ0(R1) r @efectiva % aR1b ! 0 % @202 r operando2 % a@202b % 75 R5 r resultado % aR5b % 75 . 75 % 0 䊏 BIF SI CERO R5,Ⲇ50(PC) Como aR5b % 0 la instrucción salta. Ⲇ50(PC) r @efectiva de salto % aPCb ! 50 % 100 ! 50 % @150 PROBLEMA 13 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 202; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837; aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 204, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20 a@201b % 424, a@202b % 75, a@203b % 30, a@204b % 75, a@205b % 7 Indicar para la secuencia de instrucciones propuestas, si salta o no salta la instrucción y cuál es @efectiva de salto. SUB R5 !(@27),Ⲇ0(R1) BIF SI CERO R5,Ⲇ50(PC) BIF SI NO CERO, R5, !(@203) Solución: 䊏 SUB R5 !(@27),Ⲇ0(R1) !(@27)r@efectiva%a@27b!1%204!1%@205roperando1%a@205b%7. Valor final de @27 es 205. Ⲇ0(R1) r @efectiva % aR1b ! 0 % 202 ! 0 % @202 r operando2 % % a@202b % 75 R5 r resultado % aR5b % 7 . 75 䊏 BIF SI CERO R5,Ⲇ50(PC) Como R5 no es cero la instrucción no salta. Ⲇ50(PC) r @efectiva de salto % aPCb ! 50 % 102 ! 50 % @152. El PC inicial es 100. Suponemos que en @100 está almacenada la primera instrucción. El PC se actualiza al principio de la ejecución de la instrucción. La segunda instrucción está en la posi-


309

ción 101, pero cuando se calcula la dirección de salto el PC ya ha sido actualizado, por eso su valor es 102. 䊏 BIF SI NO CERO, R5, !(@203) Como R5 no es cero la instrucción salta. !(@203) r @efectiva de salto % a@203b ! 1 % 30 ! 1 % @31. El contenido final de @203 es 31. PROBLEMA 14 Sabiendo que a@10b % 100; a@99b % 50, a@100b % 25; aR4b % 50 Indicar el contenido de los registros y de la memoria cuando se ejecutan estas 3 instrucciones. a) LOAD R6 ,-(@10) b) ADD R7,R6, 50(R4)c)

STORE R7 !(@10)

Solución: 䊏 a)

Load R6 ,-(@10) -(@10) r @efectiva fuente % a@10b . 1 % 100 . 1 % @99 r contenido de la posición de memoria fuente % a@99b % 50. El contenido final de @10 es 99 R6 r contenido final del destino % aR6b % 50

䊏 b) ADD R7,R6,Ⲇ50(R4)R6 r operando 1 % aR6b % 50 Ⲇ50(R4)- r @efectiva%aR4b!50%50!50 % % @100 r operando2%a@100b % 25. El valor final de R4 es 49 R7 r resultado % aR7b % 25 ! 50 % 75. 䊏 c)

STORE R7 !(@10) usa R7 r contenido del registro fuente aR7b % 75 !(@10) r @efectiva destino % a@10b ! 1 % 99 ! 1 % @100 r contenido final del destino % a@100b % 75. El contenido final de a@10bes 100

Contenidos finales de memoria y registros a@10b%100, a@99b%50, a@100b%75, aR4b%49, aR6b%50, aR7b%75 PROBLEMA 15 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0, aR1b % 26, aR2b % 29; aR3b % 4; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 200, aPCb % 100

310


Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@300b % 29 a@301b % 2 a@302b % 1 a@303b % 2 Sabiendo que la instrucción de LOAD se almacena en la posición @400 indicar el contenido de los registros y de las posiciones de memoria cuando acaba de ejecutarse el bucle LOAD R5,(R1) ADD R4, ,R5, (R2). STORE R4,(R1)! SUB R3,R3,Ⲇ1 BNEZ R3,200(R7) Solución: Lo primero de todo es ver que este segmento de código es un bucle controlado por las instrucciones. SUB R3,R3,Ⲇ1 y BNEZ R3,200(R7). El contenido inicial del registro indica las veces que se va a repetir el bucle, es decir 4 veces. La dirección de salto utiliza un modo de direccionamiento relativo a registro base. La @efectiva de salto % 200 ! aR7b % % 200 ! 200 % @400. Por lo tanto, salta a la instrucción de LOAD. Como el bucle se repite 4 veces esto quiere decir que el contenido final de R3 es 0. LOAD R5,(R1), usa como modo de direccionamiento un indirecto a registro, luego la primera dirección de memoria a la que accede es aR1b % @26. El registro R1 ve modificado su contenido por STORE R4,(R1)!, que usa un direccionamiento indirecto a registro con post incremento, luego cada vez que se ejecuta esta instrucción se incrementa en el valor contenido en R1, luego las direcciones sucesivas a las que acceden LOAD @26, @27, @28, @29 que contienen los datos 4,3,2,1. ADD R4,R5,(R2)- utiliza un modo de direccionamiento indirecto a registro con post decremento. La primera @efectiva a la que accede es @29 y cuando acaba de ejecutarse la instrucción se decrementa el contenido de R2, por lo tanto las direcciones que recorre en el bucle son @29, @28, @27, @26 que contienen los datos 1, 2, 3, 4. Por lo tanto, el resultado de sumar estos datos con los obtenidos con la instrucción de LOAD es 5, 5, 5,5 que mediante la instrucción de STORE se almacenan en las direcciones @26, @27, @28, @29. Visto lo anterior los contenidos de registros y posiciones de memoria al acabar el bucle son las siguientes: a@26b % 5, a@27b % 5, a@28b % 5, a@29b % 5, aR1b % 29, aR2b % 26, aR3b % 0, aR4b % 5,aR5b % 1, aR7b % 200 PROBLEMA 16 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 27; aR2b % 29; aR3b % 6; aR4b % 25; aR5b % 27; aR6b % 76; aR7b % 100, aPCb % 100


311

Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 14, a@300b % 29 a@301b % 2 a@302b % 1 a@303b % 2 Sabiendo que la instrucción de LOAD se almacena en la posición @130 indicar el contenido de los registros y de las posiciones de memoria cuando acaba de ejecutarse el bucle LOAD R5,Ⲇ3(R1) ADD R4, R5, !(R2) STORE R4,Ⲇ6(R1)! SUB R6,R6,Ⲇ2 BEZ R6,30(R7) Solución: Este segmento de programa es un bucle controlado por las instrucciones SUB R6,R6,Ⲇ2 y BEQ R6,30(R7). El bucle se repite mientras el contenido de R6 sea cero, como inicialmente aR6b % 76, el resultado de las resta es 74, luego este bucle sólo se ejecuta una vez. Al final aR6b % 74 LOAD R5,Ⲇ3(R1): Ⲇ3(R1) r @efectiva fuente % aR1b ! 3 % 27 ! 3 % @30 r operando fuente %a@30b % 14 R5 r contenido del destino % aR5b % 14 ADD R4,R5, !(R2): R5 r operando1 aR5b % 14 !(R2) r @efectiva % aR2b ! 1 % 29 ! 1 % @30 r operando2 % a@30b % 14. El contenido final del R2 es 30 R4 r resultado % aR4b % 14 ! 14 % 28. STORE R4,Ⲇ6(R1)! R4 r fuente % aR4b % 28 Ⲇ6(R1) ! r @efectiva destino % aR1b ! 6 % 27 ! 6 % @30 r a@30b % 28. El valor final de R1 es aR1b % 28 PROBLEMA 17 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 202; aR2b % 89; aR3b % 29; aR4b% 25; aR5b % 27; aR6b % 676; aR7b % 202; aPCb % 100

312


Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 202, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20 a@201b % 424, a@202b % 75, a@203b % 30, a@204b % 75, a@205b % 7 Indicar 5 formas diferentes de direccionar al dato almacenado en la posición @202. Solución: Directo a memoria @202 Indirecto a registro (R7) Relativo a registro base Ⲇ175(R5) Relativo a contador de programa Ⲇ102(PC) Indirecto a memoria (@27)

8.6 Problemas propuestos PROBLEMA 1 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27, aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 203 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena, cuál es el resultado de las siguientes instrucciones y contenido final de los registros R4 y R5: a) ADD R3,R5,!(R4) b) SUB R3,-(R4),(R5)! Sabiendo que el primer operando de las operaciones es el destino. PROBLEMA 2 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837


313

Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@30b % 654 a@200b % 29, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena, cuál es el resultado de las siguientes instrucciones y el contenido final de R3 y @202,@203 y @204: a) SUB R7,(@200)!,Ⲇ1(R3)b) MUL -(@202),(@203),(@204)! Sabiendo que el primer operando de las operaciones es el destino. PROBLEMA 3 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 100; aR2b % 89; aR3b % 29; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 837 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 87, a@26b % 986, a@27b % 75, a@28b % 876, a@29b % 63, a@57b % 65, a@54b % 20, a@201b % 424, a@202b % 28, a@203b % 30, a@204b % 27, a@205b % 53 Indicar dónde se almacena y cuál es el resultado de las siguientes instrucciones: a) SUB @25(R3), (R4)!,!(R5) b) SUB @25(R3)-,(R4)!,!(R5) PROBLEMA 4 Sabiendo que a@10b % 100; a@99b % 50, a@100b % 25; aR4b % 50 Indicar el contenido de los registro y de la memoria cuando se ejecutan estas 3 instrucciones LOAD R6 ,(@10)ADD R7,R6, -50(R4) STORE R7 (@10)

314


PROBLEMA 5 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 26; aR2b % 29; aR3b % 10; aR4b % 25; aR5b % 27; aR6b % 80; aR7b % 100, aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 14, a@31b % 5, a@32b % 76 a@300b % 29, a@301b % 2, a@302b % 1, a@303b % 2 Sabiendo que la instrucción de LOAD se almacena en la posición @47 indicar el contenido de los registros y de las posiciones de memoria cuando acaba de ejecutarse el bucle LOAD R5,Ⲇ3(R1) ADD R4, R5, !(R2) MUL R7, (R4)-,Ⲇ45 STORE R4,Ⲇ28(R0) SUB R6,R6,Ⲇ2 BEZ R6,37(R3) PROBLEMA 6 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0, aR1b % 26, aR2b % 29; aR3b % 4; aR4b % 25; aR5b % 27; aR6b % 676; aR7b % 200, aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@25b % 6, a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 302, a@31b % 303 a@300b % 29, a@301b % 2, a@302b % 1, a@303b % 2 Sabiendo que la segunda instrucción de LOAD se almacena en la posición @400 indicar el contenido de los registros y de las posiciones de memoria cuando acaba de ejecutarse el bucle LOAD R3, (@25) LOAD R5,!(@30) ADD R4, ,R5, (@31)STORE R4,(R1)! SUB R3,R3,Ⲇ1 BNEZ R3,200(R7)


315

PROBLEMA 7 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 26; aR2b % 29; aR3b % 10; aR4b % 25; aR5b % 27; aR6b % 60; aR7b % 100, aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 14, a@31b % 300, a@32b % 301, a@33b % 303, a@34b % 303 a@300b % 29, a@301b % 2, a@302b % 1, a@303b % 2, a@304b % 7 Sabiendo que la segunda instrucción de LOAD se almacena en la posición de memoria @47, indicar el contenido de los registros y de las posiciones de memoria cuando acaba de ejecutarse el bucle LOAD R6, @28 LOAD R5,!Ⲇ4(R1) LOAD R7,!Ⲇ3(R1) ADD R4, 0Ⲇ(R5)!, (R7)! MUL R4, R4,Ⲇ45 STORE R4,Ⲇ28(R0) SUB R6,R6,Ⲇ10 BEZ R6,Ⲇ37(R3)

PROBLEMA 8 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 26; aR2b % 29; aR3b % 10; aR4b % 25; aR5b % 27; aR6b % 60; aR7b % 100, aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 14, a@31b % 300, a@32b % 301, a@33b % 303, a@34b % 303, a@300b % 29, a@301b % 2, a@302b % 1, a@303b % 2, a@304b % 7 Proponer 5 modos de direccionamiento diferentes para acceder al dato que se encuentra en @303.

316


PROBLEMA 9 Sabiendo que el banco de registros contiene los siguientes datos: aR0b % 0; aR1b % 26; aR2b % 29; aR3b % 10; aR4b % 25; aR5b % 27; aR6b % 60; aR7b % 100, aPCb % 100 Y que el contenido de un conjunto de posiciones de memoria es el que aparece a continuación: a@26b % 4, a@27b % 3, a@28b % 2, a@29b % 1, a@30b % 14, a@31b % 300, a@32b % 301, a@33b % 303, a@34b % 303, a@300b % 29, a@301b % 2, a@302b % 1, a@303b % 2, a@304b % 7 Proponer 5 modos de direccionamiento diferentes para acceder al dato que se encuentra en @303.

El formato de las instrucciones es la forma en que se especifica el significado de cada bit de la instrucción. El formato debe contener toda la información necesaria para que se ejecute la instrucción. Esta información se agrupa en campos. Algunos de los campos más habituales son: Operación que realiza la instrucción (OPCODE). Modo de direccionamiento (CMD). Dirección de los operandos (DIRF). Dirección resultado (DIRD). En las instrucciones de bifurcación dirección de la instrucción a la que salta (DIRS). Tipos de representación de operandos (RN). Por ejemplo, una instrucción del tipo A % B OP C podría tener un formato como el siguiente: a:b

c:d

f:g

h:i

j:k

l:0

OPCODE

CMD

DIRA

DIRB

DIRC

RN

La primera fila de la tabla indica los bits dedicados a cada campo de la instrucción, la segunda fila indica el nombre de cada campo. Generalmente al representar el formato de una instrucción se da el significado y los bits que ocupa cada campo en el formato. Si suponemos la instrucción A % B ! C almacenada en el registro de instrucciones (RI) entonces se puede decir que RIaa:bb % OPCODE RIac:db % CMD RIaf:gb % DIRA y así sucesivamente

318


La longitud total de la instrucción viene dada por el número total de bits que necesita el formato para contener toda la información necesaria. En el caso del ejemplo en número de bits de la instrucción sería a ! 1. No todos los formatos necesitan los mismos campos ni el mismo número de campos. La longitud total de la instrucción es la longitud del formato mayor. Por ejemplo, sea la instrucción de bifurcación condicional BIF RZ,@M que consulta un registro Z, y si se cumple la condición salta a la dirección de memoria @M, su formato podría ser m:n

o:p

q:0

OPCODE

DIRZ

@M

Si a b m, esto quiere decir que el tamaño de la instrucción tiene que ser a!1, por lo tanto la instrucción de bifurcación debe tener también un tamaño a!1. El nuevo formato quedaría a:b

c:d

f:x

y:0

OPCODE

DIRA

@M

NSU

Siendo los bits RIay:0b % NSU un conjunto de bits que no se usan en este formato. La decisión del tamaño que debe tener una instrucción es crítica en el diseño del computador ya que determina la riqueza y flexibilidad de la máquina. El programador desea que su repertorio de instrucciones tenga más códigos de operación, más modos de direccionamiento, más operandos y mayor rango de direcciones, porque todo ello facilita la tarea de escribir programas. Todas estas características necesitan mayores longitudes de instrucción. El diseñador del sistema debe buscar un equilibrio entre la riqueza del repertorio de instrucciones, la necesidad de salvar espacio de memoria y la complejidad final del camino de datos. Como norma general la longitud de instrucción debe ser igual a la longitud de la transferencia de memoria o ser múltiplo de ella.

9.1 Campos de la instrucción Como ya hemos indicado, la instrucción se divide en campos, donde un campo es una cadena de bits continuos. Cada campo proporciona información específica. Campos típicos de una instrucción son: Código de operación. Dirección de operandos. Modo de direccionamiento. Extensión de campo. El código de operación indica la operación a realizar por la instrucción. Este campo puede contener más información. Por ejemplo, los modos de direccionamiento pueden ir incluidos en este código, o ir en un campo independiente. El campo de dirección especifica la dirección de un dato, resultado o instrucción a la que se bifurca. Lógicamente existirán tantos campos dirección como operandos tenga la instruc-

Capítulo 9 Teoría del formato de instrucciones

319

ción. Igual que ocurría con el código de operación puede incluir implícitamente los modos de direccionamiento utilizados (si el modo de direccionamiento se incluye en el código de operación no se incluye aquí y viceversa). En algunas ocasiones el código de operación no tiene un número constante de bits sino que varía en función del tipo de instrucción. En estos casos se tiene un número bits fijo y pequeño para casi todas las operaciones y para algunas de ellas se utiliza una extensión. El código corto se suele utilizar en las instrucciones que más se usan. La extensión se suele utilizar en instrucciones del tipo bifurcación condicional y desplazamiento. Vamos a ver un ejemplo de esto. Supongamos que tenemos el siguiente conjunto de instrucciones a codificar: Suma, resta, multiplicación, bifurcación incondicional, bifurcación si z, bifurcación si c, bifurcación si x, bifurcación si no x. La forma de utilizar la extensión de código sería la siguiente: Suma

00

Resta

01

Multiplicación

10

Bifurcación

11.

La combinación de bits 11 le indica a la unidad de control que ese formato utiliza una extensión de dos bits más para codificar la operación, quedando el código de operación de extensión variable como se ve a continuación: Suma

00

Resta

01

Multiplicación

10

Bifurcación Incondicional

1100

Bifurcación si z

1101

Bifurcación si x

1110

Bifurcación si no x

1111

9.2 Características del conjunto de formatos Como se ha visto, un procesador puede tener varios formatos y cada instrucción encaja en uno. Cuando existen varios formatos, es el código de operación el que diferencia entre ellos. Cuanto menos formatos tenga el repertorio, más sencilla será la implementación en HW del procesador. Los formatos múltiples complican el HW. Esta complejidad se reduce si de un formato a otro, los campos del mismo tipo tienen la misma longitud y ocupan la misma posición. Esto simplifica la codificación y los caminos internos necesarios para mover la información. Además se debe intentar que instrucciones próximas utilicen codificaciones similares Por ejemplo, sean estos dos formatos:

320


OPCODE

CMD

DIRA

RN

DIRQ

OPCODE

DIRB

DIRC

RN

NSU

Los dos son correctos pero complican enormemente el diseño del camino de datos. Unos formatos óptimos serían: OPCODE

CMD

DIRA

DIRB

DIRC

RN

OPCODE

NSU

DIRQ

NSU

NSU

RN

9.3 Problemas resueltos PROBLEMA 1 Determinar la longitud del formato de las instrucciones de un procesador sabiendo que su repertorio tiene 8 instrucciones del tipo OP D,F que usan el modo de direccionamiento directo a memoria. La memoria principal tiene 512 posiciones. Solución: Hay 8 instrucciones, por lo tanto para el código de operación se necesitan 3 bits. Para 512 posiciones de memoria se necesitan 9 bits de dirección, entonces: 20:18

17:9

8:0

OPCODE

Destino (DM)

Fuente (DM)

Las instrucciones tienen una longitud de 21 bits. PROBLEMA 2 Sea un procesador con una palabra máquina de 64 bits y 128 registros de propósito general. El procesador puede ejecutar 12 instrucciones diferentes de un operando. Este operando puede usar dos modos direccionamiento: el directo a registro (DR) y el relativo a registrobase (RB). a) Diseñar el formato de instrucción para este computador. b) Hallar el máximo valor del desplazamiento sabiendo que es un número expresado en complemento a dos (C2). c)

Si se quiere añadir las instrucciones LOAD RD,@M y LOAD RD,(@M) al procesador usando RD un modo de direccionamiento directo a registro y siendo @M un direccionamiento directo de memoria y (@M) un direccionamiento indirecto de memoria, ¿cuál sería la máxima memoria direccionable?


321

Solución: a) Como tiene 12 instrucciones diferentes necesita un campo código de operación (OPCODE) de 4 bits. Como cada instrucción tiene dos modos de direccionamiento diferentes, necesita un campo de un bit para seleccionar el modo de direccionamiento (CMD). Modo de direccionamiento relativo a registro base Necesitan un campo desplazamiento y un campo con la dirección del registro base. El formato queda: 63:60

59

58:52

51:0

OPCODE

CMD

RB

Desplazamiento

La máquina tendrá un desplazamiento de 52 bits. Modo de direccionamiento directo a registro 63:60

59

58:52

51:0

OPCODE

CMD

RB

NSU

b) El máximo desplazamiento es desde .251 a 251 . 1. c)

La instrucción de LOAD tiene dos operandos, luego no encaja con ninguno de los formatos estudiados. El número total de instrucciones es 14, que se codifican con 4 bits. Además también necesita el campo CMD para diferenciar entre los dos modos de direccionamiento de la memoria. El hecho de que una utilice un modo de direccionamiento directo a memoria y la otra un modo de direccionamiento indirecto a memoria no afecta al campo dirección de memoria (@M) 63:60

59

58:52

51:0

OPCODE

CMD

RB

@M

La máxima memoria direccionable es 252. PROBLEMA 3 Un computador con palabras de 128 bits posee 64 instrucciones diferentes de un operando, 8 registros de propósito general, y 3 modos de direccionamiento (directo a registro (DR), indirecto a registro (IR) y relativo a registro-base (RB). Diseñar un formato de instrucción para este computador. ¿Cuál es el rango de valores del desplazamiento en magnitud y signo?, ¿y en complemento a dos?

322


Solución: Como son 64 instrucciones, se necesita un OPCODE de 6 bits. Como son 3 modos de direccionamiento diferentes por instrucción se necesita un campo modo de direccionamiento (CMD) de 2 bits. Formato para modo de direccionamiento directo a registro Como el procesador tiene 8 registros el formato necesita un campo DR de 3 bits. El resto de bits de la instrucción no se usan (NSU) 127:122

121:120

119:117

116:0

OPCODE

CMD

DR

NSU

Formato para modo de direccionamiento indirecto con registro El formato es idéntico al anterior. En el modo de direccionamiento IR, un registro contiene una dirección de memoria, luego el formato necesita un campo dirección de registro (RD). Formato para el modo de direccionamiento relativo a registro base En este caso el modo de direccionamiento necesita direccionar el registro base y el desplazamiento luego el nuevo formato sería: 127:122

121:120

119:117

116:0

OPCODE

CMD

DR

Desplazamiento

El desplazamiento es de 118 bits. En magnitud y signo el rango de desplazamiento es: .2116 ! 1 m desplaza m !2116 . 1. En complemento a dos el rango del desplazamiento es: .2116 m desplaza m 2116 . 1. PROBLEMA 4 Sabiendo que la palabra de memoria tiene 32 bit y que el repertorio de instrucciones tiene 16 instrucciones diferentes, ¿cuál es la máxima memoria direccionable en los siguientes casos: a) La instrucción tiene dos operandos con direccionamiento directo a memoria (DM). b) La instrucción tiene un operando con direccionamiento directo (DR) a un banco de 32 registros y un operando con modo de direccionamiento DM. c) La instrucción tiene 3 operandos con DM. d) La instrucción tiene un solo operando DM. Solución: a) Como hay 16 instrucciones, el OPCODE es de 4 bits. Los 28 restantes se utilizan la mitad para cada operando 31:28

27:14

13:0

OPCODE

Operando 1

Operando 2

La máxima memoria direccionable son 214 posiciones.


323

b) 4 bits para el código, 5 bits para especificar la dirección del registro y 23 para dar la dirección de memoria. 31:28

27:23

22:0

OPCODE

Operando 1

Operando 2

La máxima memoria direccionable son 223 posiciones. c)

4 bits son para el código, y los 28 restantes se utilizan para dar la dirección de memoria de los tres operandos. 31:28

27:19

18:10

9:1

0

OPCODE

Operando 1

Operando 2

Operando 3

NSU

La máxima memoria direccionable son 29 posiciones. d) Se necesitan 4 bits para el código de operación, los 28 restantes se utilizan para el único operando. 31:28

27:0

OPCODE

Operando

La máxima memoria direccionable son 228 posiciones. PROBLEMA 5 Sabiendo que la palabra de memoria tiene 28 bits y que el repertorio de instrucciones tiene 12 instrucciones diferentes, la instrucción tiene dos operandos con un modo de direccionamiento directo a memoria. a) ¿Cuál es la máxima memoria direccionable? b) ¿Qué tamaño debe tener el registro contador de programa? c)

¿Se te ocurre algún método para conseguir direccionar más memoria sin modificar los modos de direccionamiento ni el tamaño de la palabra de memoria?

Solución: a) Se tienen 12 instrucciones, por lo tanto para el código de operación necesito 4 bits, los 24 restantes se utilizan la mitad para cada operando 27:24

23:12

11:0

OPCODE

Operando1

Operando 2

La máxima memoria direccionable son 212 posiciones. b) El contador de programa guarda la dirección de memoria de la siguiente instrucción a ejecutar, por lo tanto, debe ser capaz de almacenar cualquier dirección de memoria, es decir, debe tener un ancho de 12 bits.

324


c)

Utilizar formatos que ocupen dos palabras de memoria. Se debería incluir un campo en la instrucción que indicara a la UC que esa instrucción ocupa dos palabras de memoria. Suponiendo que esa información se incluye en el OPCODE el formato podría quedar: Primera palabra 27:0

Segunda palabra 27:0

55:52

51:26

25:0

OPCODE

Operando 1

Operando 2

La máxima memoria direccionable son 226 posiciones. PROBLEMA 6 Se desea diseñar un repertorio de instrucciones con el menor número de bits posible. La memoria puede direccionar hasta 28 palabras. El código de operación va a ser fijo. El procesador va a tener 9 registros de propósito general. El repertorio está compuesto de: 20 instrucciones de 3 operandos que permiten direccionamiento directo e indirecto de registro. 150 instrucciones de 2 operandos que permiten direccionamiento directo e indirecto de memoria. 30 instrucciones de 1 operando con directo a memoria. 26 instrucciones de 0 operandos. Hallar el formato de las instrucciones. Solución: Primero se va a estudiar el formato de cada uno de los tipos sin tener en cuenta el resto. 3 operandos: todas pueden usar dos modos de direccionamiento (directo o indirecto), por lo tanto, se necesita un bit de modo de direccionamiento (CMD) por operando. Como existen 9 registros, se necesitan 4 bits para direccionarlos. Por lo tanto son 5 bits del código de operación ! 5 bits por cada operando. 19:15

14

13:10

9

8:5

4

3:0

OPCODE

CMD1

DR1

CMD2

DR2

CMD3

DR3

2 operandos: 2 tipos de direccionamiento, por lo tanto se necesita 1 bit de modo de direccionamiento, 8 bits para cada dirección y 8 bits para el OPCODE bits más para cada operando. 25:18

17

16:9

8

7:0

OPCODE

CMD1

@M1

CMD2

@M2


325

1 operando: Direccionamiento directo de memoria, entonces se necesita acceder a 28 posiciones de memoria. 12:8

7:0

OPCODE

@M1

0 operandos: Sólo se necesitan los 5 bits del código de operación. 4:0 OPCODE

Todos los formatos tienen que tener el mismo tamaño. Además para simplificar el diseño y la complejidad del camino de datos y la unidad de control se intenta que de un formato a otro, los campos del mismo tipo, tengan la misma longitud y ocupan la misma posición. 25:18

17

16

15

14:11

10:7

6:3

2:0

OPCODE

CMD1

CMD2

CMD3

DR1

DR2

DR3

NSU

25:18

17

16

15:8

7:0

OPCODE

CMD1

CMD2

@M1

@M2

25:18

17:8

7:0

OPCODE

NSU

@M2

25:18

17:0

OPCODE

NSU

PROBLEMA 7 Sabiendo que una memoria tiene un bus de direcciones de 8 bits, un banco de 8 registros y dieciséis operaciones diferentes, ¿cuál será la longitud del registro de instrucciones? a) Suponiendo que las instrucciones tienen dos operandos cuyo modo de direccionamiento es directo a memoria. b) Suponiendo que la instrucción tiene tres operandos con modos de direccionamiento directo a memoria. c)

Suponiendo instrucciones de 3 operandos, con modo de direccionamiento directo a registro y el resto indirecto a memoria.

326


Solución: a) Se tienen 16 instrucciones, por lo tanto para el código de operación se necesitan 4 bits. Para la memoria se necesitan 8 bits. (@M % Dirección de memoria). 19:16

15:8

7:0

OPCODE

@M

@M

b)

c)

27:24

23:16

15:8

7:0

OPCODE

@M

@M

@M

Para seleccionar los registros se necesitan 3 bits. 22:19

18:16

15:8

7:0

OPCOD

DR

@M

@M

PROBLEMA 8 Suponemos una memoria con un bus de direcciones de 16 bits y un banco de 16 registros. Los modos de direccionamiento utilizados van a ser tres: directo a memoria (DM), directo a registro (DR), inmediato de 8 bits (Ⲇ). Las operaciones con sus correspondientes modos de direccionamiento van a ser las siguientes: ADD DR,DR ADD DR,DM ADD DM,DR ADD DM,DM MOVE Ⲇ,DR BCNE DM BCGT,DM ¿Cuál es la longitud máxima de la instrucción? Encontrar todos los formatos de las instrucciones. Solución: Para direccionar la memoria se necesitan 16 bits y para seleccionar un registro 4. A la hora de codificar las instrucciones tenemos dos opciones, podemos seleccionar la suma como una única operación con cuatro modos o podemos considerarlas como cuatro operaciones diferentes. En el primer caso, necesitamos 2 bits para codificar los 4 tipos de operaciones: ADD, MOVE, BCNE y BCGT. Además se deben añadir dos bits para diferenciar los modos de direccionamiento de ADD, en total 4. Sin embargo, si considero cada operación de ADD como una instrucción diferente, sólo debo codificar siete instrucciones y necesito únicamente 3 bits. Por


327

lo tanto esta última opción parece la más acertada si buscamos el formato de instrucción con el menor tamaño posible. Utilizando el código de operación fijo, la longitud máxima corresponde a la instrucción ADD DM,DM. Esta instrucción tiene 3 bits para el código de operación y 16 para cada operando con direccionamiento directo a memoria, en total 35 bits. Busquemos ahora todos los formatos de las instrucciones. (Nota NSU % bits que no se usan en el formato): ADD DM,DM 34:32

31:16

15:0

OPCODE

@M

@M

ADD DR,DM 34:32

31:20

19:16

15:0

OPCODE

NSU

DR

@M

34:32

31:20

19:16

15:12

11:0

OPCODE

NSU

DR

DR

NSU

ADD DR,DR

ADD DM,DR 34:32

31:16

15:12

11:0

OPCODE

@M

DR

NSU

MOVE ⲆIN,DR 34:32

31:24

23:16

15:12

11:0

OPCODE

NSU

ⲆINM

DR

NSU

BCNE DM 34:32

31:16

15:0

OPCODE

@M

NSU

34:32

31:16

15:0

OPCODE

@M

NSU

BCGT DM

328


PROBLEMA 9 La máquina ESCOCIA tiene un tamaño de palabra de memoria de 64 bits, 64 registros de propósito general y además su repertorio de instrucciones tiene las siguientes características: 20 instrucciones de tipo I, con 3 operandos y modos de direccionamiento directo a registro los 2 primeros e inmediato el tercero. 20 instrucciones de tipo R con 3 operandos y modos de direccionamiento directo a registro los 2 primeros y relativo a registro base con desplazamiento el tercero. 24 instrucciones de tipo J que tienen 1 operando y modo de direccionamiento directo a memoria. Sabiendo que el código de operaciones es fijo, calcular: a) El formato de las instrucciones. b) Tamaño de la memoria. Solución: a) Hay un total de 64 instrucciones, vamos a asignar un código que incluya el tipo de operación y el modo de direccionamiento. Instrucciones tipo I 63:58

57:52

51:46

45:0

OPCODE

D

F1

Ⲇinmediato

63:58

57:52

51:46

45:40

39:0

OPCODE

D

F1

RB

Ⲇdesplazamiento

Instrucciones de tipo R

Instrucciones de tipo J 63:58

57:0

OPCODE

@dirección de memoria

b) La memoria tendrá 258 posiciones. PROBLEMA 10 Queremos implementar un procesador con el siguiente repertorio de instrucciones ADD D,F1,F2 ADD D,F1,Ⲇ SUB D,F1,F2


329

SUB D,F1,Ⲇ MUL D,F1,F2 DIV D,F1,F2 BIF INCON,@M BIF MAYOR QUE, RC, ⲆD(PC) BIF MENOR QUE, RC, ⲆD(PC) BIF, IGUAL QUE, RC, ⲆD(PC) Siendo los modos de direccionamiento: D,F1,F2,RC directo a registro Ⲇ inmediato ⲆD(PC) relativo a contador de programa @M directo de memoria Suponer un banco de 32 registros y una memoria de 4 megas. Suponer también que todas las instrucciones tienen el tamaño de una palabra de memoria. El repertorio de instrucciones del procesador no va a ser ampliado en un futuro. Estudiar el formato de instrucciones del procesador, intentando que el tamaño de los operandos inmediatos sea el mayor posible. ¿Cuál es este tamaño? ¿Qué tamaño tiene la palabra de memoria? Solución: Tenemos 5 tipos de operación diferentes, por lo tanto necesitamos 3 bits para codificar el código de operación: Operación

OPCODE

ADD

000

SUB

001

MUL

010

DIV

011

BIF

100

La suma y la resta. Como tienen las mismas características las tratamos juntas. Estas dos instrucciones tienen que identificar el tipo de direccionamiento que están usando. Como tienen dos modos de direccionamiento cada una, con un bit será suficiente para identificarlos: Modo de direccionamiento

CMD

Registro-registro-registro

0

Registro-registro-inmediato

1

330


Además para el primer modo de direccionamiento necesitan incluir en la instrucción las tres direcciones los dos operandos fuentes y el destino. Como el banco tiene 32 registros el número de bits necesarios para direccionarlos es 5. Luego el formato quedaría de la siguiente manera: 18-16

15

14:10

9:5

4:0

OPCODE

CMD

RD

RF1

RF2

Según este formato las instrucciones deberían tener un mínimo de 19 bits. Vamos a ver el formato para el segundo modo de direccionamiento. En este caso se sustituye el campo RF2 por el campo inmediato, que provisionalmente vamos a considerar tiene 5 bits, aunque sólo al final del estudio, cuando determinemos la longitud mínima necesaria para incluir todos los formatos, se fijará su longitud: 18:16

15

14:10

9:5

0:4

OPCODE

CMD

RD

RF1

Ⲇ

Multiplicación y división Estas instrucciones sólo tienen un modo de direccionamiento, luego no es necesario añadir el campo CMD. El formato queda: 17:15

14:10

9:5

4:0

OPCODE

RD

RF1

RF2

Instrucciones de bifurcación Como existen cuatro tipos de instrucciones necesitaremos dos bits para codificarlo: Tipo de bifurcación

CTB

Incondicional

00

Mayor que

01

Menor que

10

Igual que

11

Como el enunciado nos dice que no está pensado ampliar el repertorio de instrucciones en un futuro, eso nos indica que no tenemos que reservar bits en el código de operaciones para futuras nuevas instrucciones. Como de los tres bits de código de operación que necesitamos para codificar los cinco tipos de instrucciones no se usan 4 combinaciones, vamos a usarlas


331

para incluir en el código de operación el tipo de instrucción condicional. Luego el código de operación queda como sigue: Operación

OPCODE

ADD

000

SUB

001

MUL

010

DIV

011

BIF incondicional

100

BIF mayor que

101

BIF menor que

110

BIF igual que

111

Ahora, para cada una de estas instrucciones tenemos que ver el resto de campos que necesita. En general podemos decir que las instrucciones de bifurcación necesitan contener la dirección a la que van a saltar, en caso de que la condición se cumpla, y un campo con la dirección del registro que contiene el valor que vamos a utilizar para calcular la condición. En el caso de las bifurcaciones incondicionales, no necesitan condición, por lo tanto sólo hay que incluir la dirección de salto, que en este caso es una dirección de memoria completa. Como la memoria tiene 4 megas se necesitan 22 bits para direccionar todas sus posiciones. Luego el formato queda: 24:22

21:0

OPCODE


Para el resto de bifurcaciones la dirección de memoria utiliza el modo relativo a contador de programa. Como sólo hay un contador de programa en el procesador no se necesita direccionar explícitamente luego será suficiente un campo desplazamiento: 24:22

21:17

16:0

OPCODE

RC

Desplazamiento

Donde desplazamiento es la cantidad que se suma al contador de programa para obtener la dirección de salto. Como de todos los formatos estudiados el que necesita más bits es el de la bifurcación incondicional, el tamaño de formato mínimo será 25. Teniendo esto en cuenta se tienen que reajustar el resto de formatos a este tamaño. Además vamos a cambiar la posición de los campos de manera que los que tengan los mismos contenidos ocupen las mismas posiciones:

332


ADD D,F1,F2 y SUB D,F1,F2 24:22

21:17

16:12

11

10:6

5:0

OPCODE

RD

RF1

CMD

RF2

NSU

ADD D,F1,F2, Ⲇ y SUB D,F1,Ⲇ 24:22

21:17

16:12

11

10:0

OPCODE

RD

RF1

CMD

Ⲇ

MUL D,F1,F2 y DIV D,F1,F2 24:22

21:17

16:12

11

10:6

5:0

OPCODE

RD

RF1

NSU

RF2

NSU

BIF INCON,@M 24:22

21:0

OPCODE


BIF CONDICIONALES 24:22

21:17

16:0

OPCODE

RF

Desplazamiento

PROBLEMA 11 Se quiere diseñar un procesador con un banco de 64 registros y una memoria de 1 giga. La Unidad Aritmético-Lógica (UAL) se va controlar desde la unidad de control y el repertorio va a tener las siguientes instrucciones: ADD R,@M,R, siendo @M modo de direccionamiento directo de memoria. SUB D,R,R. BIFURCACIÓN INCONDICIONAL con un modo de direccionamiento relativo a registro base, suponiendo un desplazamiento de 15 bits. LOAD que mueve información de la memoria a un registro y que utiliza los modos de direccionamiento directo a registro e indirecto a memoria. Además, se quiere dejar preparado el repertorio de instrucciones para incluir 5 nuevos tipos de instrucciones aritmético-lógicas en posteriores implementaciones del procesador. Hallar los formatos de las instrucciones sabiendo que una instrucción debe ocupar solo una palabra de memoria e indicar el tamaño mínimo que debe tener la palabra de memoria. ¿Cómo será el formato de la instrucción STORE, que mueve información del banco de registros a la memoria, si usa los mismos modos de direccionamiento que el LOAD?


333

Solución: Tenemos 4 instrucciones diferentes y se quiere dejar el formato preparado para ampliar el repertorio con 5 tipos de instrucciones más, por lo tanto el número total de tipos de instrucción a codificar sería 9, por lo que el campo OPCODE necesita 4 bits: Tipo de operación

OPCODE

ADD

0000

SUB

0001

Bifurcación incondicional

0010

LOAD

0011

Futuras

Resto de códigos

Vamos a estudiar los formatos de cada tipo de instrucción. ADD Tiene que tener dos campos que contengan la dirección de un registro. Como el banco de registros es de 64 bit, necesita dos campos de 6 bits cada uno. El otro direccionamiento es directo a memoria, por lo tanto en la instrucción se tiene que incluir una dirección completa de memoria. Como la memoria máxima direccionable es de 1 giga, el campo tiene que tener 30 bits. Por lo tanto el formato de las instrucciones será. El siguiente 45:42

41:36

35:30

29:0

OPCODE

RD

RF1

@M

SUB La resta tiene que incluir tres campos que contengan direcciones de registro 17:14

13:8

7:4

3:0

OPCODE

RD

RF1

RF2

BIFURCACIÓN INCONDICIONAL El modo de direccionamiento relativo a registro base necesita un registro base que almacena una dirección de memoria y un desplazamiento. Luego el formato necesita una dirección de registro y un desplazamiento 24:21

20:15

14:0

OPCODE

RB

Desplazamiento

334


LOAD Necesita un campo que contenga la dirección del registro y otro campo que contenga la dirección de memoria necesaria para implementar el modo de direccionamiento indirecto a memoria. 39:36

35:30

29:0

OPCODE

RD

@memoria

El formato de mayor tamaño es el de la suma, por lo tanto tenemos que adaptar todos los formatos a este tamaño. ADD 45:42

41:36

35:30

29:0

OPCODE

RD

RF1

@memoria

45:42

41:36

35:30

29:24

23:0

OPCODE

RD

RF1

RF2

NSU

SUB

BIFURCACIÓN INCONDICIONAL 45:42

41:36

35:30

29:15

14:0

OPCODE

NSU

RF

Desplazamiento

NSU

45:42

41:36

35:30

29:0

OPCODE

RD

NSU

@memoria

LOAD

Como una palabra de memoria debe ser capaz de contener como mínimo una instrucción completa el tamaño es de 46 bits. Las instrucciones de LOAD y STORE tendrán el mismo formato. El campo de dirección de registro será fuente o destino en función de que la instrucción sea STORE o LOAD. 45:42

41:36

35:30

29:0

OPCODE

RD/RF

NSU

@memoria


335

PROBLEMA 12 Repite el problema 11 pero suponiendo que la unidad aritmético-lógica se controla desde el registro de instrucciones. Solución: En el primer caso las señales que controlan la unidad aritmético-lógica se generan en la unidad de control. En el segundo caso estas señales se extraen directamente del registro de instrucciones. En lo que al formato concierne, la diferencia reside en que hay que separar el código de operación (OPCODE) de la operación aritmético-lógica a realizar (COPAL). Por lo tanto consideramos 3 tipos de operaciones: Las instrucciones aritmético-lógicas, que incluyen la suma, la resta y las futuras 5 operaciones aritmético-lógicas. Las bifurcaciones incondicionales. Las instrucciones de LOAD. Por lo tanto se necesitan dos bits para codificarlas: Tipo de instrucción

OPCODE


00

Bifurcación incondicional

01

LOAD

10

Los formatos de las instrucciones de LOAD y de bifurcación incondicional no se ven alterados sustancialmente, salvo en el tamaño del OPCODE y por lo tanto en el tamaño total del formato. En las instrucciones de suma y resta aparece un nuevo campo, que llamamos COPAL, que indica el tipo de operación aritmética que se va a realizar. Los bits de este campo atacan directamente a la unidad aritmético-lógica. Si sólo tuviéramos la suma y la resta con un bit sería suficiente. Como además tenemos que dejar el formato preparado para 5 nuevas instrucciones aritmético-lógicas vamos a necesitar 3 bits para codificarlas: 46:45

44:39

38:33

32:3

2:0

OPCODE

RD

RF1

@memoria

COPAL

46:45

44:39

38:33

32:27

26:3

2:0

OPCODE

RD

RF1

RF2

NSU

COPAL

336


46:45

44:39

38:33

32:18

17:0

OPCODE

NSU

RF

Desplazamiento

NSU

46:45

44:39

38:33

32:3

2:0

OPCODE

RD

NSU

@memoria

NSU

PROBLEMA 13 Sea un procesador con un banco de 8 registros. Un modelo de ejecución, memoria, registro, una memoria con una palabra de 32 bits que puede ejecutar las dos siguientes instrucciones: MULTIPLICACIÓN Fuente1, Fuente2/Destino DIVISIÓN Fuente1, Fuente2/Destino Utilizando Fuente 1 un direccionamiento relativo a registro base y Fuente2/Destino direccionamiento directo a registro. Hallar el formato de las instrucciones. ¿Qué tamaño podría tener la memoria? Solución: El procesador sólo ejecuta dos instrucciones luego necesita sólo un bit como código de operación: Operación

OPCODE

Multiplicación

0

División

1

Ambas instrucciones necesitan un campo para direccionar el Fuente2/Destino y el Fuente1. El Fuente2/Destino es una dirección de registro, como hay 8 registros necesitamos 3 bits. El Fuente1/Destino utiliza un modo de direccionamiento relativo a registro base, por lo tanto necesita un campo para direccionar el registro base y otro que contiene el desplazamiento, luego el formato para ambas instrucciones sería el siguiente: 31

30:28

27:25

24:0

OPCODE

RF2/D

RB

Desplazamiento

En el modo de direccionamiento relativo a registro base, el registro suele contener una dirección de memoria, luego el tamaño de la memoria vendrá fijado por el tamaño del registro. Los registros se cargan desde memoria y la memoria tiene una palabra de 32 bits, luego la máxima memoria direccionable será 232.


337

PROBLEMA 14 Sea un procesador que ejecuta instrucciones de tres operandos (Fuente1, Fuente2, Destino) con los siguientes modos de direccionamiento: la Fuente1 usa Ⲇrelativo a PC con un desplazamiento de 17 bits, la Fuente2 usa Ⲇinmediato de 16 bits, el Destino el directo a memoria y las bifurcaciones el relativo a PC con un desplazamiento de 10 bits. El repertorio de instrucciones es el siguiente: Suma Resta And lógica Or lógica Bifurcación incondicional Bifurcación condicional si positivo Bifurcación condicional si negativo Bifurcación condicional si cero Las instrucciones de bifurcación consultan un registro de estado que contiene información sobre la última operación realizada. La UAL se controla desde el registro de instrucciones. La memoria tiene un tamaño de 128 K palabras con 64 bits por palabra. Hallar el formato de las instrucciones. Solución: Hay dos tipos de instrucciones. Por un lado las aritmético-lógicas que comprende las suma, resta, and, or y bifurcaciones condicionales, a las que hay que añadir un campo que nos indique cuál es la operación a realizar COPAL y por el otro las bifurcaciones. Por lo tanto sólo necesito un bit como código de operación: Tipo de instrucción

OPCODE


0

Bifurcaciones

1

Como tenemos 4 operaciones aritmético-lógicas necesitamos 2 bits para codificar el tipo de operación aritmético-lógica: COPAL Suma

00

Resta

01

And

10

Or

11

338


La suma, la resta, la and y la or tienen el mismo formato puesto que necesitan la misma información para direccionar los operandos y el destino: Fuente1 necesita un desplazamiento, puesto que el contador de programa es único y no necesita incluir la información en el formato. Fuente2 necesita un campo de 16 bits para el inmediato. Destino es una dirección de memoria y por lo tanto necesita 17 bits para direccionarse 63

62:51

52:36

35:19

18:2

1:0

OPCODE

NSU

Desplazamiento

Ⲇinmediato

@memoria

COPAL

Las bifurcaciones van a necesitar un campo extra para determinar el tipo de bifurcación: CC Incondicional

00

Si positivo

01

Si negativo

10

Si cero

11

63

62:51

52:36

35:19

18:2

1:0

OPCODE

NSU

Desplazamiento

NSU

NSU

CC

El formato de las bifurcaciones incondicionales es idéntico al de las condicionales. La diferencia está en la ejecución de la instrucción porque las primeras no consultan el registro de estado. PROBLEMA 15 Sea un procesador con una palabra máquina de 64 bits y 128 registros de propósito general que puede ejecutar las siguientes instrucciones: suma, resta, LOAD y STORE. Las sumas y restas pueden direccionar sus operandos y destinos de tres formas diferentes: Los dos operandos y el destino usan modo de direccionamiento directo a registro (DR). El primer operando y el destino usan DR y el segundo operando es un inmediato (Ⲇ). El primer operando y destino con DR, y el segundo operando con un direccionamiento de página base (PB). El LOAD y el STORE pueden utilizar dos modos de direccionamiento diferentes para referirse a la posición de memoria: directo a memoria (DM) y relativo a registro base (RB). Hallar los formatos suponiendo que la unidad aritmético-lógica se controla desde la unidad de control y que la página base es la mitad de la memoria.


339

Solución: Como se indica que la unidad aritmético-lógica se controla desde la unidad de control, no hay que incluir un campo COPAL en el formato de las instrucciones aritmético lógicas y toda la información necesaria para distinguir el tipo de instrucción queda contenida en el código de operación: Instrucción

OPCODE

Suma

00

Resta

01

LOAD

10

STORE

11

La suma y la resta tienen los mismos modos de direccionamiento, por lo tanto el formato va a ser común a las dos instrucciones. Cada una de ellas tiene tres modos de direccionamiento diferentes, luego necesitamos un campo modo de direccionamiento (CMD) de 2 bits Modo de direccionamiento

CMD

DR-DR-DR

00

DR-DR- Ⲇ

01

DR-DR-PB

10

Vamos a ver el formato y el número de bits mínimo para cada uno de los casos DR-DR-DR 63:62

61:60

59:53

52:46

45:39

38:0

OPCODE

CMD

RD

RF1

RF2

NSU

63:62

61:60

59:53

52:46

45:0

OPCODE

CMD

RD

RF

Ⲇ

63:62

61:60

59:53

52:46

45:0

OPCODE

CMD

RD

RF1

Dir página base

DR-DR-Ⲇ

DR-DR-PB

340


Vamos a ver el formato del LOAD/STORE. Esta instrucción también tiene dos modos de direccionamiento diferentes, luego en el formato habrá que incluir un campo de 1 bit que distinga entre ellas. Modo de direccionamiento

CMD

Directo a memoria

0

Relativo a registro base

1

LOAD /STORE con direccionamiento directo a memoria: El formato tiene que incluir un campo dirección de registro destino de 7 bits. Esta campo va a ser común para el LOAD y el STORE. En el LOAD hace de registro destino, en el STORE hace de registro fuente. Además tiene que incluir un campo dirección de memoria. Como la página base es la mitad de la memoria y necesita 46 bit para direccionarse, para direccionar la memoria completa necesitamos 47 bits 63:62

61

60

59:53

52:47

46:0

OPCODE

NSU

CMD

RD/RF

NSU

@dir memoria

Formato de LOAD/STORE con direccionamiento relativo a registro base: El modo de direccionamiento relativo a registro base necesita un campo para direccionar el registro y un campo para el desplazamiento 63:62

61

60

59:53

52:46

45:0

OPCODE

NSU

CMD

RD/RF

RB

Desplazamiento

PROBLEMA 16 Sea un procesador con secuenciamiento explícito, una memoria de 4 K palabras de 64 bits cada una y 128 registros de propósito general que ejecuta 9 tipos diferentes de instrucciones aritmético-lógicas: 7 son de dos operandos, OP F1, F2/D donde F1 usa modo de direccionamiento relativo a índice (RI) y directo a registro (RD) y F2/D usa modo de direccionamiento (DR). 2 son de un operando OP F1 y usa direccionamiento relativo a índice (RI) y directo a registro (RD). Además ejecuta LOAD, STORE y bifurcaciones incondicionales con modos de direccionamiento DR y relativo a registro base (RB). Las instrucciones aritmético-lógicas pueden operar con números representados en complemento a uno (C1), complemento a dos (C2) y magnitud y signo (MS). Hallar el formato de las instrucciones suponiendo que la unidad aritmético-lógica se controla desde el registro de instrucciones.


341

Solución: Como el direccionamiento es explícito, todos las instrucciones deben tener un campo que contenga la dirección de la siguiente instrucción (@MIRSI). Lo primero vamos a fijar el código de operación de las instrucciones. Como la UAL se controla desde el registro de instrucciones el número total de instrucciones diferentes que podemos ejecutar es 12. Por lo tanto necesitamos 4 bits de código de operación (OPCODE). Formato de las instrucciones aritmético-lógicas de dos operandos Cada una de ellas puede tener dos modos de direccionamiento diferentes para su primer operando y un modo para su segundo, por lo tanto necesitamos un campo que indique el modo de direccionamiento elegido (CMD). Con 1 bit será suficiente: Modo de direccionamiento

CMD

Relativo a índice-directo a registro

0

Directo a registro-directo a registro

1

Si suponemos que para las instrucciones de un operando la fuente es siempre la fuente 1 el formato de las de dos operandos y de uno es idéntico. Aritmético-lógicas relativo a índice-directo a registro El modo de direccionamiento relativo a índice necesita un campo dirección registro base y un campo dirección de memoria (@M). Además necesitamos un campo que contenga la dirección del registro Fuente2/Destino. Por último, un campo de dos bits para codificar el formato de número usado (CFNU). 63:60

59

58:52

51:40

39:33

32:31

30:19

18:0

OPCODE

CMD

RB

@M

RF2/RD

CFNU

@MIRSI

NSU

Aritmético lógicas directo a registro-directo a registro 63::60

59

58:52

51:40

39:33

32:31

30:19

18:0

OPCODE

CMD

RF1

NSU

RF2/RD

CFNU

@MIRSI

NSU

Instrucciones de LOAD y STORE El modo de direccionamiento relativo a registro base necesita un campo registro base (DRB) y un campo desplazamiento que, para simplificar el formato, se va a suponer que tiene el mismo número de bits que la dirección de memoria. Por lo tanto el formato queda: 63::60

59

58:52

51:40

39:33

32:31

30:19

18:0

OPCODE

NSU

DRB

Desplazamiento

RF/RD

NSU

@MIRSI

NSU

342


Instrucción de bifurcación incondicional: 127

59

58:52

51:40

39:33

32:31

30:19

18:0

OPCODE

NSU

DRC

Desplazamiento

NSU

NSU

@MIRSI

NSU

PROBLEMA 17 Sea un procesador con un banco de 16 registros y una palabra de memoria de 14 bits cuyo repertorio de instrucciones tiene las siguientes características: Instrucciones tipo a: 3 instrucciones de tres operandos. Instrucciones tipo b: 14 instrucciones con dos operandos. Instrucciones tipo c :30 instrucciones con 1 operando. ¿Es posible codificar este repertorio si todos los operandos se encuentran en el banco de registros? Solución: Está claro que con un código de tamaño fijo no es posible codificar todas estas instrucciones, pero sí es posible utilizando un código extensible o de tamaño variable. Este tipo de código se aprovecha de que las instrucciones con menos operandos necesitan menos bits para almacenar la información y utiliza los bits sobrantes para codificar las operaciones. Codificación y formato de las instrucciones tipo A: Hay tres instrucciones de este tipo, por lo tanto se necesitan 2 bits de OPCODE. La última combinación 11 no se usa. Además se necesitan 12 bits para direccionar los tres operandos 13:12

11:8

7:4

3:0

OPCODE

R1

R2

R3

Siendo el OPCODE: Instrucciones tipo A

OPCODE

I1

00

I2

01

I3

10

No se usa

11

Codificación y formato de las instrucciones tipo B: El código no usado antes, 11, le indica a la unidad de control que el código de operación tiene 6 bits. Se utilizan los bits 11:8 para ampliar el código de operación. Por lo tanto el formato, y sus correspondientes códigos quedan como sigue 13:12

11:8

7:4

3:0

11

EXT – OPCODE

R2

R3


Instrucciones tipo B

OPCODE

EXT–OPCODE

I0

11

0000

I1

11

0001

—

—

—

I13

11

1101

No se usa

11

1110

No se usa

11

1111

343

Codificación y formato de las instrucciones tipo C: Igual que ocurría antes, de las posibles combinaciones de los 6 bits más significativos (13:8) hay 2 combinaciones que no se usan: la 11 1110 y la 111 1111. Estas combinaciones indican a la unidad de control que el código de operación de las instrucciones no va a tener 6 bits sino 10 y se utilizan los bits 7:4 para extender el código de operación, puesto que estas instrucciones no los necesitan 13:12

11:8

7:4

3:0

11

1110

EXT –OPCODE2

R3

13:12

11:8

7:4

3:0

11

1111

EXT –OPCODE2

R3

OPCODE

EXT–OPCODE

EXT–OPCODE2

I0

11

1110

0000

—

11

1110

—

I15

11

1110

1111

I16

11

1111

0000

I17

11

1111

0001

—

11

1111

—

I29

11

1111

1101

Instrucciones tipo B

PROBLEMA 18 Un computador de 15 bits palabra máquina y 8 registros, tiene el siguiente repertorio de instrucciones: Tipo A: 7 instrucciones de referencia de un solo operando en memoria, con direccionamiento directo a memoria (DM) e indirecto de memoria (IM). Tipo B: 15 instrucciones con dos operados y dos modos de direccionamiento diferentes. En el primero los dos operandos usan un modo de direccionamiento directo a

344


registro (DR) y en el segundo los dos operandos usan un modo de direccionamiento indirecto de registro (IR). Tipo C: 16 instrucciones sin operando explícito. a) Hallar el formato de las instrucciones utilizando un código de operación extensible intentando maximizar la memoria direccionable. b) Especificar la zona de memoria alcanzable en cada tipo de direccionamiento y rango posible de valores de los operandos (en C2). Solución: a) Empezamos el estudio con las únicas instrucciones que tienen direcciones de memoria. Como hay 7 instrucciones se necesita un código de operación de 3 bits: Tipo A

OPCODE

I1

000

I2

001

—

—

I7

110

No se usa

111

Formato, hay que incluir un campo modo de direccionamiento de un bit: 14:13

12:1

0

OPCODE

@M

CMD

Instrucciones con dos operandos. Formato y codificación. La última combinación del OPCODE (11) avisa a la UC que hay una extensión de código Tipo B

OPCODE

EXT–OPCODE

I1

11

0000

I2

11

0001

—

11

I15

11

1110

No se usa

11

1111

14:13

12:9

8:7

6:4

3:1

0

OPCODE

EXT–OPCODE

NSU

DR

DR

CMD


345

Instrucciones sin operando. Cuando la UC ve que OPCODE y EXT–OPCODE están todo a 1’s sabe que hay una extensión de código Tipo C

OPCODE

EXT–OPCODE

EXT–OPCODE2

I1

11

1111

0000

I2

11

1111

0001

—

11

—

—

I16

11

1111

1111

14:13

12:9

8:5

4:0

OPCODE

EXT–OPCODE

EXT–OPCODE2

NSU

b) 211posiciones de memoria y rango de valores de .214 a 214 . 1. PROBLEMA 19 Se tiene un computador con un ancho de palabra de 32 bits y con un banco de 32 registros. El computador tiene 64 instrucciones y los siguientes modos de direccionamiento: directo de página base (DPB), indirecto a página base (IPB), relativo a registro-base (RRB) y directo a registro (DR). a) Diseñar los formatos de las instrucciones de dos operandos sabiendo que siempre un operando está en memoria y otro en registro. b) Si cada dirección de memoria especifica un byte, ¿a qué zona de memoria se puede acceder con cada uno de los modos de direccionamiento? Solución: a) Se tienen 64 instrucciones, luego se necesitan 6 bits para codificar la operación (OPCODE). Como son 3 modos de direccionamiento, se necesitan 2 bits para codificar el modo de direccionamiento (CMD). Modo de direccionamiento

CMD

DPB-DR

00

IPB-DR

01

RRB-DR

10

Estos dos campos son comunes a todas las instrucciones. Vamos a estudiar a continuación el resto de los campos para cada tipo de modo de direccionamiento.

346


Directo a memoria. Necesita un campo que contenga la dirección de memoria, luego el formato quedaría: 31:26

25:24

23:5

4:0

OPCODE

CMD

@DIR MEMORIA

DREG

Indirecto a memoria. La instrucción contiene la dirección de una posición de memoria que contiene la dirección de memoria en la que se encuentra la dirección. El formato es idéntico al de directo a memoria. 31:26

25:24

23:5

4:0

OPCODE

CMD

@DIR INDIR MEMORIA

DREG

Relativo a registro base. Este modo de direccionamiento necesita dos campos, uno que contenga la dirección del registro base y otro que contenga el desplazamiento. 31:26

25:24

23:19

18:5

4:0

OPCODE

CMD

DRB

Desplazamiento

DREG

b) Para el directo de página base se pueden direccionar 219 bytes, como una palabra de memoria son 4 bytes, el rango direccionable es: 219/4 % 217 palabras de 32 bits. Para el indirecto de página base, como la dirección efectiva se encuentra almacenada en la memoria y la palabra de memoria son 32 bits del rango total será: 232 bytes, con 4 bytes/palabra luego el rango direccionable es: 232/4 % 230 palabras de 32 bits. Para el indirecto con desplazamiento a registro-base: Suponiendo que el desplazamiento se expresa en C2, el rango de desplazamiento es: [.213, 213 . 1]. Como el rango del registro base es: [0,232 . 1]. Se podría pensar en un rango total de: [.213, 232 ! 213 . 2]. Pero como el computador tiene ancho de palabra de 32 bits la suma RB!despl. se hace en módulo 232, lo que quiere decir que el rango direccionable es 232 B o lo que es lo mismo 230 palabras. PROBLEMA 20 Sea un computador con palabra máquina de 32 bits y 16 registros. La memoria es de 256 M palabras. El juego de instrucciones de esta máquina se reduce a dos instrucciones ortogonales: Move origen, destino y Add, operando1, operando2/destino. Los modos de direccionamiento permitidos son: directo a registro (DR) y relativo a registro base (RRB). Diseñar los formatos de instrucción de la máquina descrita.


347

Solución: Hay dos tipos de instrucciones, luego el campo código de operación (OPCODE) tiene 1 bit. Los dos tipos de instrucciones tienen 4 modos de direccionamiento diferentes: Modo de direccionamiento

CMD

DR-DR

00

DR-RRB

01

RRB-DR

10

RRB-RRB

11

El formato será el mismo tanto para la instrucción de move como para la instrucción de suma. Directo a registro-directo a registro 31

30:29

28:25

24:21

20:0

OPCODE

CMD

DRF1

DRF2/D

NSU

Directo a registro-relativo a registro base y relativo a registro base-directo a registro Les podemos hacer coincidir puesto que los campos código de modo de direccionamiento nos indican en cada caso cuál de los dos operandos utiliza cada campo 31

30:29

28:25

24:21

20:0

OPCODE

CMD

DRF1

DRB

Desplazamiento

Relativo a registro base-relativo a registro base 31

30:29

28:25

24:21

20:10

9:0

OPCODE

CMD

DRB1

DRB2

Desplaza1

Desplaza2

En este caso los desplazamientos serán más pequeños que en el caso anterior. El orden de los campos lo hemos elegido así para mantener el principio de que campos de diferentes formatos con el mismo que representan la misma información ocupen las mismas posiciones de los formatos.

348


9.4 Problemas propuestos PROBLEMA 1 Un computador con palabra máquina de 16 bits y 32 registros ejecuta el siguiente juego de instrucciones ortogonales: MOVE D,F ADD D, F1, F2 SUB D, F1, F2 MUL D, F1, F2 DIV D, F1, F2 AND D, F1, F2 OR D, F1, F2 XOR D, F1, F2, SHIFT D, F, tipo, contador NOT D,F Sabiendo que: La condición de la bifurcación puede ser igual que, menor que, mayor que, los modos de direccionamiento pueden ser inmediato, directo a registro y relativo a registro y directo a memoria; la información se puede representar en complemento a 2, magnitud y signo y binario puro pudiendo cada instrucción usar sólo una representación numérica; los desplazamientos pueden ser derecha e izquierda, el contador de la instrucción de desplazamiento indica el número de desplazamiento, pudiendo tener éste un valor máximo de 4. Diseñar el formato de las instrucciones para dicho juego de operaciones PROBLEMA 2 Sabiendo que un procesador tiene 16 registros de propósito general, una memoria de 1K palabras y el siguiente repertorio de instrucciones: 13 instrucciones de tres operandos que usan el modo de direccionamiento directo a memoria para el primer operando, modo de direccionamiento indirecto a memoria para su segundo operando y directo a registro para el tercero. 123 instrucciones de dos operandos, siendo el modo de direccionamiento del primero directo a memoria y del segundo indirecto a registro. Instrucciones de una dirección de 15 bits y una de 3 bits. 200 instrucciones de 0 operandos. Utilizar un código de operación extensible para implementar unos formatos con el menor tamaño posible.


349

PROBLEMA 3 Diseñar los formatos para las instrucciones de tipo registro-registro, para el repertorio de instrucciones: 72 instrucciones de 3 operandos. 26 instrucciones de 2 operandos. 56 instrucciones de 1 operando. 5 instrucciones de 0 operandos. Utilizando el menor número posible de bits para la instrucción. PROBLEMA 4 Sea un procesador con un tamaño de palabra de 64 bits y un banco de 32 registros. Además tiene un registro puntero a pila SP que apunta a la primera posición vacía de la pila. Sabiendo que su repertorio de instrucciones es: 4 operaciones aritmético lógicas de dos operandos que usan como modo de direccionamiento el directo a registro. 1 instrucción de mete pila siendo el origen un registro del banco de registros con direccionamiento directo a registro. 1 instrucción de escritura en memoria desde un registro con direccionamiento indirecto a memoria y directo a registro. 1 instrucción de lectura de memoria sobre un registro, con un direccionamiento directo a registro y direccionamiento directo a memoria. Hallar el formato de las instrucciones. PROBLEMA 5 Sea un procesador con 32 registros de propósito general y una memoria de 264 palabras que usa secuenciamiento explícito. Sabiendo que ejecuta 5 operaciones aritmético-lógicas diferentes de tres operandos que usan como modo de direccionamiento el directo a registro para el primer operando y un modo indirecto a memoria para el segundo operando/destino. Hallar su formato de instrucciones. PROBLEMA 6 Sea un procesador con un banco de 8 registros y una memoria de 220 palabras. Además tiene un registro puntero a pila SP que apunta a la última posición ocupada de la pila. El procesador puede ejecutar el siguiente repertorio de instrucciones: 4 operaciones aritmético-lógicas que usan un modo de direccionamiento directo a registro para el primer operando y el resultado; y un modo de direccionamiento relativo a registro base con un desplazamiento de 8 bits para el segundo operando, coincidiendo la dirección del primer operando y la del resultado. 4 bifurcaciones condicionales que utilizan el modo de direccionamiento relativo a PC.

350


1 instrucción de mete pila siendo el origen un registro del banco de registros con direccionamiento directo a registro. 1 instrucción de saca pila siendo el destino un registro del banco de registros con direccionamiento directo a registro. 1 instrucción de escritura en memoria desde un registro con direccionamientos directo a memoria y directo a registro. 1 instrucción de lectura de memoria sobre un registro con un direccionamiento directo a registro y directo a memoria. Hallar el formato de las instrucciones PROBLEMA 7 Sea un procesador con 64 registros de propósito general y una memoria de 235. El procesador tiene además un registro puntero a pila SP que apunta a la última posición ocupada de la pila, llenándose la pila hacia direcciones decrecientes de memoria. El repertorio de instrucciones que puede ejecutar es el siguiente: 4 operaciones aritmético-lógicas que usan un modo de direccionamiento directo a registro para ambos operandos. 4 bifurcaciones condicionales que utilizan el modo de direccionamiento relativo a PC. – – – –

Bifurcar Bifurcar Bifurcar Bifurcar

si cero. si positivo. si negativo. si mayor o igual que.

1 instrucción de mete pila siendo el origen un registro del banco de registros con direccionamiento directo a registro. 1 instrucción de saca pila siendo el destino un registro del banco de registros con direccionamiento directo a registro. 1 instrucción de escritura en memoria desde un registro con direccionamientos relativo a registro índice y directo a registro. 1 instrucción de lectura de memoria sobre un registro con un direccionamiento directo a registro e indirecto a memoria. Hallar el formato de las instrucciones. PROBLEMA 8 Sea un procesador con 128 registros de propósito general y una memoria de 256 megas. El procesador puede ejecutar las siguientes instrucciones: Sumas y restas con tres operandos que usan modo de direccionamiento directo a registros; instrucciones de bifurcación condicional que usan modo de direccionamiento relativo a registro base, siendo las condiciones mayor que y menor que, instrucciones LOAD y STORE que usan modos de direccionamiento indirecto a memoria. Hallar los formatos de las instrucciones. ¿Cómo sería el formato si el secuenciamiento fuera explícito?


351

PROBLEMA 9 Sea un procesador con 8 registros de propósito general y una memoria de 1 mega palabras. Sabiendo que puede ejecutar 1 instrucción aritmético lógica que usa un modos de direccionamiento directo a registro; 1 instrucción de bifurcación incondicional que utiliza el modo de direccionamiento relativo a PC y 1 Instrucción de escritura en memoria desde un registro con direccionamientos relativo a registro base con un desplazamiento de 8 bits y directo a registro. Hallar el formato de sus instrucciones.

a

10.1 Partes básicas de un procesador En este capítulo se va a abordar el estudio y especificación del camino de datos y la unidad de control de microprocesadores multiciclo. Un procesador multiciclo es aquel en el que una instrucción tarda varios ciclos en ejecutarse, y las instrucciones se ejecutan de una en una, sin aprovechar el posible paralelismo a nivel de instrucción existente en los programas. Este tipo de procesadores se divide en dos módulos principales: El camino de datos. La unidad de control. El camino de datos es la parte del procesador que se encarga de leer, mover, modificar y almacenar la información sobre la que computa el procesador. Se compone de registros, memoria, unidad aritmética-lógica (UAL) y hardware (HW) auxiliar, como pueden ser los multiplexores, incrementadores o sumadores. La unidad de control (UC) es el módulo que se encarga de generar la señales que controlan el camino de datos. Es un sistema secuencial que genera para cada ciclo de reloj las señales necesarias para implementar una determinada fase de la instrucción. A la UC llega información desde el registro de instrucciones y desde diferentes biestables y registros del procesador. Con esta información genera las señales necesarias en cada ciclo de reloj.

10.1.1 Los registros Los registros son elementos de memoria que se encuentran en el interior del procesador cuyo objetivo es permitir al procesador trabajar rápidamente con los datos que más se utilizan. Sus principales características son su rapidez de acceso y su pequeño tamaño. El modo de trabajar de la mayoría de los procesadores actuales es enviar datos desde la memoria a los registros del procesador mediante instrucciones de LOAD. Una vez que los datos se encuentran en los

354


registros, estos se utilizan como operandos de las instrucciones. Cuando los cómputos acaban se envían los resultados a la memoria mediante instrucciones de STORE. Los registros necesitan una señal de control carga del registro (Ld–RA) que activa la unidad de control en las fases en las que se desea realizar la carga de una información. Los registros se pueden clasificar en registros de propósito específico y registros de propósito general. Registros de propósito específico. Son registros que tienen la misión de almacenar el estado de procesador y la información necesaria para su control. Los más destacados son el Contador de Programa (PC) que almacena la dirección de la siguiente instrucción que se va ejecutar. El Registro de Instrucciones (RI) que almacena la instrucción que se está ejecutando. El registro de estado del procesador (SR) es un registro que contiene información sobre el estado en que se encuentra el procesador. Suele estar dividido en campos o bits y cada uno de ellos tiene un significado diferente. Entre los campos más habituales están: desbordamiento (overflow), acarreo, cero, positivo, negativo. Por último, se puede encontrar puntero de pila (SP). Estos registros suelen ser invisibles para el programador. Otros registros invisibles para el programador son los registros auxiliares. Se utilizan para almacenar provisionalmente información necesaria para implementar algunos tipos de instrucciones o modos de direccionamiento. Un ejemplo puede ser el registro auxiliar de direcciones necesario para implementar el modo de direccionamiento indirecto a memoria. También se pueden usar para acortar caminos combinacionales demasiado largos. Un camino combinacional suele empezar y acabar en registros. Al incluir el registro auxiliar entre estos dos registros, generalmente partiendo la lógica combinacional, se consigue aumentar la frecuencia de trabajo del procesador aunque se añaden ciclos a la ejecución de la instrucción. Registros de propósito general. Sirven para almacenar información de diferente tipo, como puede ser datos o instrucciones. Este tipo de registros son visibles para el programador, es decir están definidos en la arquitectura del procesador.

Los registros de propósito general se suelen agrupar en bancos de registros. Los bancos de registros tienen puertos de escritura o entrada y puertos de lectura o salida. Los puertos constan de un bus de direcciones y un bus de datos. En principio un banco de registros puede tener tantos buses de entrada y salida como se desee. Se puede decir que cuantos más puertos tenga, mayor número de fases en paralelo permite. Por ejemplo, si un bus tiene un único puerto de lectura, en las operaciones de dos operandos se necesita un registro auxiliar para almacenar el primer operando. Si el banco tiene dos puertos de salida se pueden leer los dos operandos al tiempo, con lo que se ahorran ciclos de ejecución. El número de registros también puede ser el que se desee, pero es importante recordar lo siguiente: cuantos más puertos tenga el banco, más complejo será y esto puede ralentizarlo. Lo mismo ocurre con el número de registros. Muchos registros dan mayor flexibilidad al programador pero también ralentiza el acceso al banco de registros. Además de los puertos, los bancos de registros necesitan una señal de capacitación de escritura (ver figura sobre el párrafo).

Capítulo 10 Diseño del camino de datos y la unidad de control

355

10.1.2 La memoria Es la unidad del sistema que almacena las instrucciones y los datos del proceso. Su tiempo de acceso es aproximadamente un orden de magnitud superior al de los registros. Esta es la razón por la que hoy en día casi todos los procesadores trabajan directamente con registros en lugar de trabajar con memoria. Tienen un bus de direcciones y un bus de datos. En los problemas supondremos una memoria con un bus de direcciones, un bus de entrada de datos y un bus de salida de datos. Además supondremos una memoria con una señal de control L/E que actúa de la siguiente manera: si L/E % 0 lee, si L/E % 1 escribe.

10.1.3 Unidad aritmético-lógica Es la unidad que realiza las operaciones aritmético-lógicas sobre los operandos. Operaciones típicas son: suma, resta, multiplicación, and, or, desplazamientos, etc. Necesita una señal de control que seleccione la operación a realizar. Como se verá más adelante la unidad aritmético-lógica (UAL) se puede controlar desde la UC o desde el RI. Esta última opción simplifica el diseño de la unidad de control.

356


10.1.4 Estudio y diseño del camino de datos Para diseñar un camino de datos es importante saber que en el procesador multiciclo una instrucción se ejecuta mediante una sucesión de pasos que se llaman fases, cada una de las cuales dura un ciclo de reloj. Una fase suele incluir: Una lectura de información que puede estar almacenada en un registro o en memoria. Para realizar la lectura se puede necesitar una dirección. Un movimiento de información, en el que suelen intervenir multiplexores que seleccionan entre diferentes caminos. Una escritura de la información en un registro o en la memoria. Fases clásicas de una instrucción son: Envío de la instrucción desde memoria al registro de instrucciones. Actualización del contador de programa. Cálculo de las direcciones de los operandos. Lectura de los operandos. Ejecución de la operación. Cálculo de la dirección del resultado. Escritura del resultado. En ocasiones, alguna de estas fases se puede descomponer en nuevas fases. Esto ocurre cuando durante la ejecución de una fase diferentes datos necesitan utilizar el mismo HW, esto no es posible y obliga a dividir la fase en tantas como sea necesario. Un ejemplo es el cálculo


357

de la dirección efectiva para el modo de direccionamiento indirecto a memoria (dos usos diferentes del bus de direcciones de memoria). Por el contrario si los datos de dos fases no utilizan el mismo HW se pueden agrupar en una única fase. Un ejemplo clásico es el de la lectura de la instrucción y la actualización del contador de programa. Agrupar fases es interesante porque ahorra ciclos de reloj en la ejecución de una instrucción. En cualquier caso es muy importante cuando se agrupan o dividan las fases para no perder de vista que la sucesión de fases debe ser la correcta. Siguiendo el principio de divide y vencerás, lo más apropiado para abordar el diseño de un camino de datos es estudiar la implementación de cada uno de los tipos de instrucciones y después unirlas todas en el camino de datos total. Implementar el camino de datos de una instrucción consiste en implementar los caminos necesarios para ejecutar cada una de las fases en que se descompone la instrucción. A la hora de implementar estos caminos es importante que el diseñador tenga en cuenta las ligaduras de diseño. Una instrucción puede implementarse de muchas maneras diferentes y cada implementación tiene unas características de área, rendimiento y consumo. Las decisiones de diseño vendrán fijadas por las ligaduras de especificación. Tanto la duración del ciclo de reloj como el número de ciclos de reloj por instrucción están determinados por la implementación final. Para conseguir un mejor diseño es conveniente tener en mente los dos principios que a continuación se enuncian: Hacer rápido el caso común. La regularidad favorece la simplicidad.

10.1.5 La unidad de control La unidad de control es un sistema secuencial que forma parte de la unidad central de proceso (CPU). Su misión es generar las señales que controlan: Las operaciones de la CPU, incluyendo las operaciones de la ALU. Los movimientos de datos en el interior de la CPU. Los movimientos de datos entre la CPU y la memoria. Los movimientos de datos y de señales de control con los interfaces exteriores. Las entradas del sistema secuencial son ciertos campos del registro de instrucciones, como el campo código de operación, código de condición en instrucciones de bifurcación, y código de operación aritmético-lógica a realizar. También pueden ser entrada algunos de los bits del registro de estado, o de los biestables de condición. La salida son todas las señales necesarias para controlar el camino de datos. Señales típicas son: Ld–R r capacitación de carga de registro. Mux–Camino r selección de un determinado camino. L/E r capacitación de la escritura/lectura de memoria. EC r capacitación en el banco de registros. En principio, se puede afirmar que el diagrama de estados que especifica la UC tiene tantas ramas como tipos de instrucciones. Y cada rama tiene tantos estados como fases se necesitan para implementar la instrucción. La salida para cada estado son las señales que hay que activar para que se ejecute esa fase.

358


10.2 Problemas resueltos PROBLEMA 1 Se quiere implementar el procesador TIFON. Este procesador tiene un banco de 4 registros, con un bus de salida de datos y un bus de entrada de datos. La memoria tiene 1K posiciones, un bus de salida de datos, un bus de entrada de datos y un bus de direcciones. Inicialmente TIFÓN tiene tres tipos de instrucciones diferentes, uno de los cuales comprende 8 operaciones aritmético-lógicas del siguiente tipo: OP D, F1, F2:

donde

D: % F1 OP F2

Los dos operandos y el destino usan el modo de direccionamiento directo a registro. Se quiere que las operaciones se controlen desde la unidad de control. a) Estudiar el formato de las instrucciones. b) Hallar el tamaño mínimo de la palabra del procesador. c)

Estudiar el módulo secuenciador.

Solución: a) Como las instrucciones aritmético-lógicas se controlan desde UC, se incluyen dentro del código de operación, luego en total hay 10 tipos de instrucciones diferentes, así pues se necesitan 4 bits para el código de operación (OPCODE). Además hay que añadir tres campos de 2 bits para incluir las direcciones de los operandos y el destino. El formato queda: 9:6

5:4

3:2

1:0

OPCODE

D

F1

F2

b) Suponemos que una instrucción se puede leer en un único acceso a memoria, por lo tanto el tamaño de la palabra de procesador será 10 bits. c) El módulo secuenciador es el que se encarga de generar la dirección efectiva de memoria. En este caso la única dirección que se genera es la que indica la posición de la siguiente instrucción y que se encuentra en el PC. Como se supone el procesador con direccionamiento implícito, la siguiente dirección se genera incrementando en 1 el contenido del PC, luego el módulo secuenciador es:


359

PROBLEMA 2 Implementar el camino de datos de TIFÓN, especificando claramente las señales de control del HW. Solución:

El registro auxiliar de datos, AUX, es necesario porque el banco de registros sólo tiene un bus de salida, por lo tanto el primer dato leído tiene que almacenarse porque si no se perdería al leer el segundo operando. Las señales de control del camino de datos son las siguientes: Ld–PC carga del contador de programa PC. Ld–RI carga del registro de instrucciones RI. Ld–aux carga del registro auxiliar de datos AUX. COPAL selección de la operación a realizar. Esta señal se genera en la unidad de control. Mux–L selecciona la dirección del registro que se va a leer. L/E lectura /escritura de memoria (%0 lee,%1 escribe). EC escritura del banco de registros. PROBLEMA 3 Dado el procesador anterior a) Analizar la ejecución de las instrucciones sobre el camino de datos, indicando qué señales de control se tienen que activar en cada caso. b) Estudiar el diagrama de estados de la unidad de control. c)

Hallar la especificación de la unidad de control.

d) ¿Cómo se puede simplificar esta unidad de control?

360


Solución: a) El análisis consiste en estudiar cada uno de los movimientos atómicos en los que se descompone la ejecución de una instrucción, indicando las señales de control necesarias para llevarlos a cabo. La ejecución de todas las instrucciones empieza siempre por la lectura de la instrucción de la memoria y la decodificación de la misma: 1.a fase. Búsqueda de la instrucción (BUS). En esta fase se lee la instrucción de la memoria y se incrementa el contador de programa – Operaciones atómicas: RI:%M[PC]; PC:%PC!1 – Señales de control: Ld–RI%1, Ld–PC%1, L /E%0 2.a fase. Decodificación (DEC). Es una fase de decisión que necesita la UC para saber cuál es el tipo de instrucción cargada en RI. En principio, en esta fase no se realiza ninguna acción, por lo tanto todas las señales de control están inactivas. En ocasiones se puede usar para ahorrar ciclos de reloj realizando acciones que no modifiquen el estado del procesador y para las que no es necesario conocer el tipo de instrucción. 3.a fase. Lectura del primer operando (POR) – Operaciones atómicas: AUX:%F1 – Señales de control: Ld–aux%1, Mux–L%1 4.a fase. Lectura del segundo operando, ejecución y escritura en banco de registros (SORE). Todas estas acciones se pueden realizar en la misma fase si el ciclo de reloj es lo suficientemente largo. Recordar que los registros se leen al principio del ciclo y que el banco de registro se escribe al final del ciclo. – Operaciones atómicas: D:%F2 OP AUX – Señales de control: Mux–L%0, COPAL%operación, EC%1 b) Como se puede ver en la figura, las dos primeras fases son comunes a todas las instrucciones, pero a partir de ahí se bifurca en tantas ramas como instrucciones, en este caso 8.


c)

361

La especificación para cada rama es: Entrada UC

Estado UC

OPCODE

Fase

XXXX

Señales de control Ld – PC

Ld – RI Ld – aux Mux – L

L/E

EC

COPAL

BUS

1

1

0

X

0

0

X

DEC

0

0

0

X

0

0

X

POR

0

0

1

1

0

0

X

SOREi

0

0

0

0

0

1

OPi

Debajo de OPCODE aparece XXXX porque hasta el momento se desconoce el valor del código de operación para cada una de las operaciones aritmético-lógicas. Se puede observar que las señales de multiplexación en algunas ocasiones tienen el valor X. Esto indica que es indiferente el valor que adopten en esa fase. d) Las señales de control que implementan las diferentes operaciones sólo se diferencian en la señal COPAL que depende de cada operación. Por lo tanto se pueden considerar las fases BUS, DEC y POR comunes a todas las instrucciones. Como se puede ver en la siguiente figura

Esta simplificación no ahorra ciclos de reloj pero la unidad de control será más sencilla y por lo tanto más rápida. PROBLEMA 4 Estudiar una optimización para la unidad de control de TIFÓN que permite ahorrar ciclos de reloj en las instrucciones sin modificar el HW.

362


Solución: La fase de lectura de primer operando se realiza para todas las instrucciones. Esta fase no modifica el estado del computador, por lo tanto se puede incluir dentro de decodificación, con lo que se ahorra un ciclo de reloj en todas las instrucciones. El diagrama de estado queda:

La especificación de la unidad de control queda: Entrada UC

Estado UC

OPCODE

Fase

XXX

Señales de control Ld–PC

Ld–RI

Ld–aux Mux–L

L/E

EC

COPAL

BUS

1

1

0

X

0

0

X

DEC/POR

0

0

1

1

0

0

X

SOREi

0

0

0

0

0

1

OPi

PROBLEMA 5 Considerando el procesador anterior: a) ¿Se ahorrarían ciclos de reloj si el banco de registros tuviera dos buses de salida en lugar de uno y dos buses de direcciones de lectura? b) ¿Se podría incluir en la fase de decodificación alguna otra fase para ahorrar ciclos de reloj a la ejecución de las instrucciones? c)

Suponiendo una sola operación aritmético-lógica, ¿se podría incluir en decodificación alguna otra fase para ahorrar ciclos de reloj en la ejecución de las instrucciones?

Solución: a) El camino de datos con un banco de registros con dos buses de salida quedaría de la siguiente manera:


363

Como el banco de registros tiene dos buses de salida no se necesita el registro auxiliar de datos, AUX, para almacenar el primer operando. Por lo tanto, se puede realizar la lectura de los dos operandos, la ejecución y la escritura en el banco de registros en el mismo ciclo de reloj. El análisis de las instrucciones es el siguiente: 1.a fase. Búsqueda de la instrucción (BUS). – Operaciones atómicas: RI:%M[PC], PC:%PC!1 – Señales de control: Ld–RI%1, Ld–PC%1, L/E%0 2.a fase. Decodificación (DEC). 3.a fase. Lectura de operandos ejecución y escritura en el banco de registros (LOSE). – Operación atómica: D%F1 Op F2 – Señales de control: EC%1 El diagrama de estados es el siguiente:

364


Por lo tanto, el número de ciclos necesarios para ejecutar una instrucción es el mismo que en el caso anterior, pero el tiempo de ciclo es más largo puesto que se leen los operandos, se ejecuta la operación y se escribe el resultado todo en el mismo ciclo, por lo tanto es una opción peor puesto que el procesador trabaja a una frecuencia inferior. Además el banco de registros con dos puertos de lectura es más complejo, más lento y más caro. b) No, la LOSE es diferente para cada operación puesto que tiene que generar la señal COPAL que selecciona la operación que realiza la unidad aritmético-lógica. c)

Esto quiere decir que en lugar de 8 ramas diferentes el diagrama tendría sólo una. El diagrama quedaría como se ve a continuación:

Con este diagrama antes de saber el tipo de instrucción que se está ejecutando se escribe un dato sobre el banco de registros, es decir se modifica el estado del procesador. Esto no tendría mayor importancia si esta fuera la única instrucción que se ejecuta, pero recordar que aparte de las operaciones aritmético-lógicas se ejecutan otros 2 tipos de instrucciones, por lo tanto no se puede realizar esta modificación. PROBLEMA 6 Se quiere crear una nueva versión de TIFÓN que se llamará TIFÓN.20, La idea es simplificar la unidad de control controlando las 8 operaciones aritmético-lógicas desde el registro de instrucciones. a) Estudiar el formato de las instrucciones. b) ¿Cómo afecta al camino de datos? Solución: a) La principal diferencia es que la señal de control COPAL se incluye en el registro de instrucciones. OPCODE necesita dos bits para codificar los tres tipos de instrucciones. En el caso de las instrucciones aritmético-lógicas hay que añadir un campo que indique el tipo de operación que se va a ejecutar (COPAL). Este campo tiene 3 bits para codificar las ocho operaciones. El formato queda: 10:9

8:7

6:5

4:3

2:0

OPCODE

D

F1

F2

COPAL


Tipos de instrucciones

365

OPCODE

Tipo 1

00

Tipo 2

01

Tipo 3 – Aritmético-lógicas

10

La palabra mínima del procesador es de 11 bits. b) El cambio más notable es que se ha sustituido la señal COPAL generada por la UC por la señal COPAL almacenada en RI, (RIa2:0b). También han cambiado los bits que sirven para direccionar los operandos y el destino.

PROBLEMA 7 Dado el procesador TIFÓN.20 a) Analizar la ejecución de las instrucciones sobre el camino de datos, indicando qué señales de control se tienen que activar en cada caso. b) Diagrama de estados de la unidad de control. c)

Especificación de la unidad de control.

Solución: a)

1.a fase. Búsqueda de la instrucción (BUS). – Operaciones atómicas: RI:%M[PC], PC:%PC!1; – Señales de control: Ld–RI%1, Ld–PC%1, L/E%0 2.a fase. Decodificación (DEC).

366


3.a fase. Lectura del primer operando (POR). – Operación atómica: AUX:%F1 – Señales de control: Ld–aux%1, Mux–L%1 4.a fase. Lectura del segundo operando, ejecución y escritura en banco de registros (SORE). – Operación atómica: D:%F2!AUX – Señales de control: Mux–L%0, EC%1. Fijarse que en esta fase no aparece la señal de control COPAL que se generaba en el problema 1. b) Este diagrama es más sencillo que el anterior por lo que resta complejidad a la unidad de control.

c)

Entrada UC

Estado UC

OPCODE

Fase

10


Ld–RI

Ld–aux Mux–L

L/E

EC

BUS

1

1

0

X

0

0

DEC

0

0

0

X

0

0

POR

0

0

1

1

0

0

SORE

0

0

0

0

0

1

PROBLEMA 8 Se quiere implementar el nuevo TIFÓN.30, más flexible que el anterior procesador. Para conseguirlo se van a utilizar nuevos modos de direccionamiento en las operaciones aritmético-lógicas dando lugar a las instrucciones OP D,F1,@M, donde F1 usa un modo de direccionamiento directo a registro, (DR), y @M es un modo de direccionamiento directo a memoria (DM): a) Estudia el formato de estas nuevas instrucciones. b) Estudia la unidad secuenciadora necesaria para implementarlas. Solución: a) El nuevo formato es: 18:17

16:15

14:13

12:3

2:0

OPCODE

D

F1

@M

COPAL

Se incluye el campo @M que contiene una dirección de memoria de 10 bits. La palabra de máquina mínima es de 19 bits.


367

b) Se necesita un multiplexor que seleccione entre las dos posibles direcciones de memoria: la almacenada en el contador de programa y la almacenada en el registro de instrucciones.

PROBLEMA 9 Estudia el camino de datos necesario para implementar las instrucciones del problema anterior. Explica las señales necesarias para controlarlo. Solución: No hace falta multiplexor para seleccionar las direcciones de lectura del banco de registros puesto que sólo se lee un operando.

Desde el registro de instrucciones se proporciona la dirección del destino, y de los dos operandos. Además se proporciona también la operación aritmético-lógica. Desde la unidad de control se generan las siguientes señales: Mux–@- selecciona la dirección efectiva de memoria. EC capacitación de escritura del banco de registros. L/E lectura escritura de memoria (para L%0 lectura). Ld–PC -capacitación de escritura del contador de programa. Ld–RI capacitación de escritura del registro de instrucciones.

368


PROBLEMA 10 Dado el procesador anterior: a) Analizar la ejecución de las instrucciones sobre el camino de datos, indicando qué señales de control se tienen que activar en cada caso. b) Diagrama de estados de la unidad de control. c)


Solución: a)

1.a fase. Búsqueda de la instrucción (BUS). – Operaciones atómicas: RI:%M[PC], PC:%PC!1 – Señales de control: Ld– PC%1; Ld– RI%1, MUX–@%0,L/E%0 2.a fase. Decodificación (DEC). 3.a fase. Lectura de los operandos, ejecución y escritura de la solución en el banco de registros (LOEE). – Operación atómica: D:%F1 OP M[@D] – Señales de control: EC%1, MUX–@%1, L/M%0 Los caminos de datos parciales necesarios para traer los dos operandos son diferentes, por lo tanto se pueden traer los dos en el mismo ciclo de reloj.

b)

c) Entrada UC

Estado UC

OPCODE

Fase

10


Ld–RI

Mux–@

L/E

EC

BUS

1

1

0

0

0

DEC

0

0

X

0

0

LOEE

0

0

1

0

1

PROBLEMA 11 Analizando el camino de datos y la unidad de control del anterior problema, ¿cuál crees que es su principal problema y cómo se podría solucionar?


369

Solución: El camino que tiene que recorrer el segundo operando es demasiado largo. Tiene que llegar la dirección al bus de direcciones de la memoria pasando por el multiplexor, se tiene que leer la memoria, tiene que llegar el dato hasta la unidad aritmético-lógica, se tiene que realizar la operación, tiene que llegar el resultado a la entrada del banco de registros y se tiene que escribir el dato en el banco de registros. Como todas estas acciones se tienen que realizar en un ciclo de reloj, la frecuencia final de trabajo va a ser muy baja, lo que puede perjudicar a otro tipo de instrucciones implementadas. Una posible solución sería cortar el camino del segundo operando mediante un registro de auxiliar lo que añadiría un ciclo a todas estas instrucciones pero permitiría unos ciclos más cortos y por lo tanto mayor frecuencia, lo que podría beneficiar a los demás tipos de instrucciones:

Como ya se ha comentado la inclusión de este registro auxiliar de datos afecta a la ejecución de estas instrucciones añadiéndoles un ciclo más. La 3.a fase LOEE se descompone en dos fases: Una fase de lectura del segundo operando (SOM) y otra fase de ejecución y escritura (EE). El primer operando no necesita ninguna acción especial para leerse. El diagrama de estados queda como sigue:

370


Y la especificación de la unidad de control Entrada UC

Estado UC

OPCODE

Fase

10

Señales de control Ld– PC

Ld– RI MUX–@ Ld– aux

L/E

EC

BUS

1

1

0

0

0

0

DEC

0

0

X

0

0

0

SOM

0

0

1

1

0

0

EE

0

0

x

0

0

1

PROBLEMA 12 Finalmente se va diseñar el procesador TIFÓN.30 incluyendo las instrucciones OP D,F1,F2 y OP D,F1,@M. Además se va usar un registro auxiliar de datos para conseguir que trabaje a una frecuencia más elevada. a) Estudiar el formato de instrucciones. b) Estudiar la unidad secuenciadora. Solución: a) A los formatos hay que añadirles un campo que indique el modo de direccionamiento del segundo operando (CMD) de un bit. Además el tamaño del formato será el del mayor formato. Intentaremos que campos de diferentes formatos con el mismo significado ocupen las mismas posiciones: Instrucciones OP D,F1,F2 19:18

17

16:15

14:13

12:11

10:3

2:0

OPCODE

CMD

D

F1

F2

NSU

COPAL

Instrucciones OP D,F1,@M 19:18

17

16:15

14:13

12:3

2:0

OPCODE

CMD

D

F1

@M

COPAL

Siendo los códigos para los tipos de operación y para los modos de direccionamiento los siguientes: Tipos de instrucciones

OPCODE

Modos de direccionamiento

CMD

Tipo 1

00

DR-DR-DR

0

Tipo 2

01

DR-DR-DM

1


10

El tamaño de palabra máquina es de 20 bits.


371

b) En el primer tipo de instrucciones la única dirección de memoria necesaria es la almacenada en PC. En el segundo tipo de instrucciones se usan dos direcciones de memoria: la almacenada en PC y la almacenada en RI. El secuenciador es:

PROBLEMA 13 Diseñar el camino de datos del procesador TIFÓN.30 para las instrucciones del Problema 12 indicando la acción que controla cada señal de control. Solución:

Para implementar las instrucciones con las dos fuentes en el banco de registros necesitamos un registro auxiliar, como vimos en el problema 1. Para implementar las instrucciones con un operando en memoria utilizábamos un registro auxiliar para hacer el ciclo total más corto. Al unir los dos caminos de datos hemos decidido utilizar un único registro auxiliar, lo

372


que permite reducir área y complejidad. Esto afectará a los pasos que hay que seguir para traer los operandos, como se verá más adelante. Señales de entrada a la unidad de control OPCODE y CMD. Señales generadas por la unidad de control: Ld–PC capacitación de carga del contador de programa PC. Ld–RI capacitación de carga del registro de instrucciones. Ld–aux capacitación de carga del registro auxiliar de datos. Mux–L selección del registro a leer del banco de registros (%0 F2,%1 F1). Mux–SO selección de la fuente del segundo operando (%0 memoria,%1 banco de registro). Mux–@ selección de la fuente de dirección de memoria (%0 PC, %1 banco de registros). L/E capacitación escritura de memoria (%0 lee, %1 escribe). EC capacitación de escritura en banco de registros (%1 escribe). La unidad aritmético-lógica se controla desde RIa2:0b. PROBLEMA 14 Considerando TIFÓN.30 a) Analizar la ejecución de las instrucciones sobre el camino de datos, indicando qué señales de control se tienen que activar en cada caso. b) Diagrama de estados de la unidad de control. c)


d) Suponiendo que el 70% de las instrucciones aritmético-lógicas que se ejecutan en el procesador tienen sus dos operandos fuente en el banco de registros, ¿qué cambio se podría introducir en la unidad de control para optimizarlas? Solución: a) Las fases de búsqueda y decodificación son comunes a los dos tipos de instrucciones: 1.a fase. Búsqueda de la instrucción (BUS). – Operación atómica RI:%M[PC], PC%PC!1 – Señales de control: Ld–PC%1, Ld–RI%1, Mux@%0,L/E%0 2.a fase. Decodificación (DEC). Instrucciones OP D,F1,F2 con OPCODE%10, CMD%0 3.a fase. Búsqueda del segundo operando en registro (SOR). – Operación atómica: AUX:%F2 – Señales de control: Ld–aux%1; Mux–SO%1,Mux–L%0


373

Se realiza primero la lectura del segundo operando porque sólo se ha puesto un registro auxiliar de datos en la segunda entrada de la UAL. 4.a fase. Lectura del primer operando en registro y ejecución (POR). – Operación atómica: D:%R1 OP AUX – Señales de control: Mux–L%1, EC%1 Instrucciones OP D,F1,@M con OPCODE%10, CMD%1 3.a fase. Lectura del segundo operando en memoria (SOM). – Operación atómica: AUX :% M[@M] – Señales de control: Mux–@%1, Mux–SO%0, Ld–aux%1 4.a fase. Lectura del primer operando, ejecución y escritura (POR2). – Operación atómica: D:%R1 OP AUX – Señales de control: Mux–L%1, EC%1 b)

c) Entrada UC Estado UC OPCODE, CMD XX, XX

10, 0

10, 1

Fase

Señales de control Ld–PC Ld–RI Ld–aux Mux–L Mux–SO Mux–@ L/E

EC

BUS

1

1

0

X

X

0

0

0

DEC

0

0

0

X

X

X

0

0

SOR

0

0

1

0

1

X

0

0

POR

0

0

0

1

X

X

0

1

SOM

0

0

1

X

0

1

0

0

POR2

0

0

0

1

X

X

0

1

374


d) Se puede incluir la búsqueda del segundo operando de las instrucciones con fuente en el banco de registros dentro de la fase de decodificación. De esta forma estas instrucciones tardan un ciclo menos en ejecutarse. La carga de esta información en el registro auxiliar no afecta a las instrucciones con un operando en memoria, puesto que en la 3.a fase de estas instrucciones se sobrescribe la información almacenada en la etapa de decodificación. El diagrama de estados queda:

La especificación de la unidad de control queda: Entrada UC Estado UC OPCODE, CMD XX, X

10, 0 10, 1

Fase

Señales de control Ld–PC Ld–RI Ld–aux Mux–L Mux–SO Mux–@ L/E

EC

BUS

1

1

0

X

X

0

0

0

DEC/SOR

0

0

1

0

1

X

0

0

POR

0

0

0

1

X

X

0

1

SOM

0

0

1

X

0

1

0

0

POR2

0

0

0

1

X

X

0

1

PROBLEMA 15 Se quieren añadir las siguientes instrucciones aritmético-lógicas OP D, (F1), @M siendo (F1) el modo de direccionamiento indirecto a registro (IR) y @M el modo de direccionamiento directo a memoria (DM), a TIFÓN 30: a) Estudiar el formato de las instrucciones. b) Estudiar la unidad secuenciadora necesaria para implementarla.


Solución: a)

18:17

16:15

14:13

12:3

2:0

OPCODE

D

F1

@M

COPAL

b)

PROBLEMA 16 Estudiar el camino de datos del problema 15. Solución:

375

376


PROBLEMA 17 Considerando el problema 16: a) Analizar la ejecución de las instrucciones sobre el camino de datos, indicando qué señales de control se tienen que activar en cada caso. b) Especificación de la unidad de control. c) Añadir estas instrucciones a TIFÓN.30, estudiando el nuevo formato, el camino de datos y la unidad de control. Solución: a)

1.a fase. Búsqueda de la instrucción (BUS). – Operación atómica: RI:%M[PC], PC:%PC!1 – Señales de control: Ld–PC%1 y Ld–RI%1, Mux–@%0,L/E%0 2.a fase. Decodificación (DEC). 3.a fase. Lectura del segundo operando (SOM): – Operaciones atómicas: AUX:%M[@M] – Señales de control: Ld–aux%1, Mux–@%1 4.a fase. Lectura del primer operando, ejecución y escritura en el banco de registro (POME). – Operación atómica: D:%M[F1] OP AUX – Señales de control: Mux–@%2, L/E%0, EC%1

b)

Entrada UC

Estado UC

OPCODE

Fase

XX, X

Señales de control Ld–aux Mux–@

Ld–PC

Ld–RI

L/E

EC

BUS

1

1

0

0

0

0

DEC

0

0

0

X

0

0

SOM

0

0

1

1

0

0

POME

0

0

0

2

0

1

c) Los formatos TIFÓN.30 eran los siguientes 19:18

17

16:15

14:13

12:11

10:3

2:0

OPCODE

CMD

D

F1

F2

NSU

COPAL

19:18

17

16:15

14:13

12:3

2:0

OPCODE

CMD

D

F1

@M

COPAL

El nuevo formato casa con el formato con modo de direccionamiento directo a memoria. La única diferencia es que el CMD necesita un bit más puesto que hay que codificar un nuevo modo de direccionamiento:


Instrucciones OP D,F1,F2 20:19

18:17

16:15

14:13

12:11

10:3

2:0

OPCODE

CMD

D

F1

F2

NSU

COPAL

Instrucciones OP D,(F1),@M y OP D,F1,@M 20:19

18:17

16:15

14:13

12:3

2:0

OPCODE

CMD

D

F1

@M

COPAL


OPCODE


CMD

Tipo 1

00

DR-DR-DR

00

Tipo 2

01

DR-DR-DM

01


10

DR-IR-DM

10

Camino de datos:

377

378


Diagrama de estados:

Especificación de la unidad de control: Entrada UC Estado UC OPCODE, CMD

Fase

Señales de control Ld–PC Ld–RI Ld–aux Mux–L Mux–PO Mux–SO Mux–@ L/E EC

BUS

1

1

0

X

X

X

0

0

0

DEC

0

0

0

X

X

X

X

0

0

SOR

0

0

1

0

X

0

X

0

0

POR

0

0

0

1

0

X

X

0

1

SOM

0

0

1

X

X

1

1

0

0

POR2

0

0

0

1

0

X

X

0

1

SOM2

0

0

1

X

X

1

1

0

0

POIR

0

0

0

1

1

X

2

0

1

X, X

10, 00

10, 01

10, 10

PROBLEMA 18 Se quieren implementar en TIFÓN.30 las instrucciones Op (@M),Ⲇd(F1),F2, donde (@M) es un modo de direccionamiento indirecto a memoria (IM) y Ⲇd(F1) es un modo de direccionamiento relativo a registro base con desplazamiento, siendo éste de 10 bits.


379

a) Estudiar el formato de la instrucción. b) Estudiar la unidad secuenciadora. c)

Estudiar el camino de datos.

d) Estudiar la unidad de control. Solución: a)

30:29

28:27

26:25

24:23

22:13

12:3

2:0

OPCODE

CMD

RF2

RB

Ⲇdesplaza

@M

COPAL

b)

La entrada 0 del multiplexor implementa el secuenciamiento implícito. La entrada 1 del multiplexor implementa el modo de direccionamiento relativo a registro base con desplazamiento. Las entradas 2 y 3 se utilizan para implementar el modo de direccionamiento indirecto a memoria. Se necesita un registro auxiliar de direcciones (AUX@) para guardar la dirección efectiva de memoria en la que se va a guardar el resultado de la operación. En el banco de registros se necesita un multiplexor para seleccionar entre los dos posibles registros de lectura, el registro base RB y el registro RF2. La entrada de dirección de escritura no necesita entrada puesto que en esta instrucción sólo se escribe en memoria.

380


c)

AUX es necesario puesto que, aunque un operando se trae de memoria y el otro se trae del banco de registros, se necesita acceder dos veces al banco de registros para obtener los operandos. d) Análisis de las instrucciones: 1.a fase. Búsqueda de la instrucción (BUS). – Operaciones atómicas: RI:%M[PC], PC:%PC!1 – Señales de control: Ld–PC%1, Ld–RI%1, Mux–@%0,L/E%0 2.a fase. Decodificación (DEC). 3.a fase. Lectura del primer operando con modo de direccionamiento relativo a registro base con desplazamiento (POMⲆ). – Operación atómica: AUX:%M[F1!d] – Señales de control: Ld–aux%1, Mux–L%1,Mux–@%1 4.a fase. Cálculo de la dirección efectiva del destino (@ED). – Operación atómica: AUX@:%M[@M] – Señales de control: Mux–@%2, Ld–aux@%1,L/E%0 5.a fase. Ejecución y escritura en memoria (EEM). – Operación atómica: M[AUX@]%AUX OP F2, – Señales de control: Mux–L%0,Mux–@%3,L/E%1


381

Diagrama de estados:

Especificación de la unidad de control: Entrada UC Estado UC OPCODE

XX

Fase

Señales de control Ld–PC Ld–RI Ld–aux Ld–aux@ Mux–@ Mux–L

L/E

EC

BUS

1

1

0

0

0

X

0

0

DEC

0

0

0

0

x

X

0

0

POMⲆ

0

0

1

0

1

1

0

0

@ED

0

0

0

1

2

x

0

0

EEM

0

0

0

0

3

0

1

0

PROBLEMA 19 Integrar estas últimas instrucciones en el procesador TIFÓN.30 especificando el formato de las instrucciones, el camino de datos y la unidad de control. Solución: Las instrucciones estudiadas en los anteriores problemas necesitan un formato de 31 bits, por lo tanto los nuevos formatos tendrán 31 bits. Instrucciones Op D,F1,F2 30:29

28:27

26:25

24:23

22:21

20:3

2:0

OPCODE

CMD

D

F1

F2

NSU

COPAL

Instrucciones Op D,(F1),@M y Op D,F1,@M 30:29

28:27

26:25

24:23

22:13

12:3

2:0

OPCODE

CMD

D

F1

000.0

@M

COPAL

Para las instrucciones Op D,F1,@M el campo RIa22:13b no se usa. Para las instrucciones Op D,(F1),@M suponemos RIa22:13b%00..0. Esto se hace para aprovechar la parte del secuenciador que implementa el modo de direccionamiento relativo a registro base. Como se puede ver en el formato de más abajo los bits RIa22:13b contienen

382


el desplazamiento, pero cuando el desplazamiento es cero, el modo de direccionamiento relativo a registro base se puede considerar indirecto a registro. Con esta decisión se simplifica el secuenciador. Instrucciones Op (@M),Ⲇd(F1),F2 30:29

28:27

26:25

24:23

22:13

12:3

2:0

OPCODE

CMD

RF2

RB

Ⲇdesplaza

@M

COPAL


OPCODE


CMD

Tipo 1

00

DR-DR-DR

00

Tipo 2

01

DR-DR-DM

01


10

DR-IR-DM

10

IRBD-DR-IM

11

Camino de datos:


Análisis de las instrucciones: 1.a fase. Búsqueda de la instrucción (BUS). – Operaciones atómicas: RI:%M[PC] Pc:%PC!1 – Señales de control: Ld–PC%1 y Ld–RI%1 Mux@%0,L/E%0 2.a fase. Decodificación (DEC). Instrucciones Op D,F1,F2 con OPCODE%10 y CMD%00 3.a fase. Lectura del primer operando en registro (POR). – Operaciones atómicas: AUX1:%F1 – Señales de control: Mux–L%1, Mux–P0%0, Ld–aux1%1 4.a fase. Lectura del segundo operando en registro (SOR). – Operación atómica: AUX2:%F2 – Señales de control: Mux–L%0, Mux–SO%0, Ld–aux2%1 5.a fase. Ejecución y escritura en banco de registros (EE). – Operación atómica: D%AUX1 Op AUX2 – Señales de control: EC%1 Instrucciones Op D,F1,@M con OPCODE%10 y CMD%01 3.a fase. Lectura del primer operando en registro (POR2). – Operación atómica: AUX1:%F1 – Señales de control: Mux–L%1, Mux–P0%0, Ld–aux1%1 4.a fase. Lectura del segundo operando de memoria (SOM). – Operación atómica: AUX2:%M[@M] – Señales de control: Mux–@%2, L/E%0, Mux–SO%1, Ld–aux2%1 5.a fase. Ejecución y escritura en el banco de registros (EE2): – Operación atómica: D:%AUX1 Op AUX2 – Señales de control: EC%1 Instrucciones Op D,(F1),@M con OPCODE%10 y CMD%10 3.a fase. Lectura del primer operando de memoria (POIR). – Operaciones atómicas: AUX1%M[F1] – Señales de control: Mux–@%1, L/E%0, Mux–PO%1, Ld–aux1%1 4a fase. Lectura del segundo operando en memoria (SOM2). – Operación atómica: AUX2%M[@M] – Señales de control: Mux–@%2, L/E%0, Mux–SO%1, Ld–aux2%1 5.a fase. Ejecución y escritura en banco de registros (EE3). – Operación atómica: D%AUX1 OP AUX2; – Señales de control: EC%1

383

384


Instrucciones Op (@M),Ⲇd(F1),F2 con OPCODE%10 y CMD%11 3.a fase. Lectura del primer operando en memoria (POMⲆ). – Operaciones atómicas: AUX1%M[F1!d] – Señales de control: Mux–L%1, Mux–PO%1,Ld–aux1%1 4.a fase. Lectura del segundo operando (SOR2). – Operaciones atómicas: AUX2:%F2 – Señales de control: Mux–L%2, Mux–SO%0, Ld–aux2%1 5.a fase. Cálculo de la dirección efectiva del resultado(@ER). – Operaciones atómicas: AUX@:%M[@M] – Señales de control: Mux–@%2, Ld–aux@%1 6.a fase. Ejecución y escritura en memoria (EEM). – Operaciones atómicas: M[AUX@]:%AUX1 Op AUX2 – Señales de control: Mux–@%3; L/E%1 Especificación de la unidad de control Entrada UC

Estado UC

OPCODE, CMD

Fase

XX, XX

10, 00

10, 01

10, 10

10, 11

Señales de control Ld–PC Ld–RI Ld–aux1 Ld–aux2 Mux–L Mux–PO Mux–SO Mux–@ L/E EC Ld–aux@

BUS

1

1

0

0

X

X

X

0

0

0

0

DEC

0

0

0

0

X

X

X

X

0

0

0

POR

0

0

1

0

1

0

X

X

0

0

0

SOR

0

0

0

1

0

X

0

X

0

0

0

EE

0

0

0

0

X

X

X

X

0

1

0

POR2

0

0

1

0

1

0

X

1

0

0

0

SOM

0

0

0

1

X

X

1

2

0

0

0

EE2

0

0

0

0

X

X

X

X

0

1

0

POIR

0

0

1

0

X

1

X

1

0

0

0

SOM2

0

0

0

1

1

X

1

2

0

0

0

EE3

0

0

0

0

X

X

X

X

0

1

0

POMⲆ

0

0

1

0

1

1

X

1

0

0

0

SOR2

0

0

0

1

2

X

0

X

0

0

0

@ER

0

0

0

0

X

X

X

2

0

0

1

EEM

0

0

0

0

X

X

X

3

1

0

0


385

PROBLEMA 20 Estudiar como quedaría TIFÓN 30 al añadirle la instrucción BIFSIZ , @M que realiza la siguiente función: SI FZ%1 r PC%@M!1, siendo FZ un biestable que se pone a 1 si el resultado de la última operación aritmético lógica es cero y si no se carga con un cero. ¿Es posible implementar las operaciones de LOAD y STORE sin modificar el camino de datos del procesador X? indica cuales deberían ser sus características y como se podría hacer? Solución:

La instrucción de LOAD y STORE son instrucciones de movimiento de datos, de memoria a banco de registros y de banco de registros a memoria. Por lo tanto, si existe un camino entre estos dos módulos se pueden implementar. Este camino existe pasando a través de la unidad aritmético-lógica. Para implementar las operaciones de LOAD se podría utilizar el camino de datos de las instrucciones que usan como operandos fuentes posiciones de memoria.

386


Para implementar las operaciones se podría utilizar el camino de datos que implementa las instrucciones que tienen como destino una posición de memoria. En la unidad aritmético-lógica habría que implementar una operación dejar pasar el dato sin operar sobre él.

10.3 Problemas propuestos PROBLEMA 1 Se quiere diseñar un procesador, que llamaremos PPM, que tenga las siguientes características: Un banco de 64 registros de propósito general, con dos buses de salida y un bus de entrada. Una memoria de 1G palabras con un bus de salida, un bus de entrada y un bus de direcciones. Una palabra de procesador de 64 bits. Que trabaje a la mayor frecuencia posible. Para diseñarlo se van a estudiar caminos parciales de instrucciones para después irlas añadiendo al camino total. Se comienza el estudio con 5 instrucciones aritmético-lógicas (AL) de dos operandos, uno de ellos es la Fuente1 y el otro hace las veces de Fuente2 y Destino. Los dos operandos utilizan el modo de direccionamiento directo a registro. Estudiar el formato de instrucciones, el camino de datos y la unidad de control. PROBLEMA 2 Estudiar el formato, el camino de datos y la unidad de control para 5 instrucciones aritméticológicas en las que el operando Fuente1 sea un inmediato de 10 bits. PROBLEMA 3 Incluye en PPM las instrucciones del problema 1 y 2 estudiando sus formatos, camino de datos y unidad de control. PROBLEMA 4 Sea una instrucción de bifurcación incondicional y cinco instrucciones de bifurcación condicional con las siguientes condiciones de salto: Mayor que. Menor que. Igual que. Mayor o igual que. Menor o igual que.


387

Las bifurcaciones pueden usar dos modos de direccionamiento: Directo a memoria y relativo a contador de programa con un desplazamiento de 15 bits. Para implementar las bifurcaciones condicionales vamos a usar un registro de estado (SR) de 3 bits cada uno de ellos con un significado: Z % 1 si el resultado de la última operación AL ha sido cero, Z % 0 en el resto de los casos. N % 1 si el resultado de la última operación AL ha sido negativo, N % 0 en el resto de los casos. P % 1 si el resultado de la última operación AL ha sido positivo, P % 0 en el resto de los casos. Este registro SR se actualiza en cada operación AL. El HW necesario para generarlos se supone incluido en la UAL. PROBLEMA 5 Rediseñar el formato del camino de datos y la unidad de control del problema 4 utilizando un módulo combinacional Generador de Condición (GC) cuya misión es simplificar la unidad de control. Las entradas a GC son los bits de registro de estados SR y los bits que indican el tipo de salto. La salida es un bit Condición (C) que le indica a la unidad de control si la condición de salto se cumple o no se cumple. PROBLEMA 6 Se quieren añadir al procesador PPM las instrucciones del problema 4 utilizando en el diseño el módulo GC. Estudiar el formato de las instrucciones, el camino de datos y la unidad de control. PROBLEMA 7 Se quiere añadir a PPM el modo de direccionamiento indirecto a memoria. a) Estudiar los formatos, el camino de datos y la unidad de control necesarios para implementar las instrucciones AL en las que los dos operandos utilizan este modo de direccionamiento. b) Se quiere que las instrucciones AL sean ortogonales, es decir que cualquiera de los operandos pueda utilizar cualquiera de los modos de direccionamiento. Estudia los formatos, el camino de datos y la unida de control necesarios para implementar esta ortogonalidad. PROBLEMA 8 Estudiar los formatos de instrucciones en camino de datos y la unidad de control que se obtienen al añadir a PPM los nuevos formatos estudiados en el problema 7b. PROBLEMA 9 A PPM le falta un conjunto de instrucciones que permita realizar movimiento de datos. Estudiar el formato de instrucciones, camino de datos y unidad de control de las instrucciones

388


Move fuente-destino donde fuente y destino pueden ser indistintamente memoria y banco de registros, utilizando los siguientes modos de direccionamiento: Directo a registro. Relativo a índice. Indirecto a memoria. PROBLEMA 10 Añadir a PPM las instrucciones del problema 9.

En un procesador multiciclo las instrucciones se ejecutan de una en una, siguiendo el orden de programa. Cada instrucción tiene varias fases y cada una de las cuales dura un ciclo de reloj. Para realizar una primera aproximación a la segmentación se parte de un procesador multiciclo que puede ejecutar los siguientes tipos de instrucciones: Operaciones aritmético lógicas enteras: OP D,F1,F2. Operaciones LOAD D,@M. Operaciones STORE F,@M. Operaciones de bifurcación condicional BIFS R,@M. Si el procesador tiene un banco de registros con dos puertos de salida, las fases de cada tipo de instrucción son las siguientes: Fases de las instrucciones Tipo de instrucciones

Ciclo 1

Ciclo 2

Ciclo 3

Ciclo 4

Aritmético- lógicas

Búsqueda

Decodificación(*) Ejecución

Escritura

LOAD

Búsqueda

Decodificación

Ejecución (I)

Memoria

STORE

Búsqueda

Decodificación

Ejecución (I)

Memoria

Bifurcaciones

Búsqueda

Decodificación

Ejecución (II)

(*) Decodificación y lectura de operandos. (I) Cálculo de la dirección efectiva. (II) Cálculo de la dirección de salto y comprobación de la condición.

Ciclo 5

Escritura

390


Vamos a ver cómo sería el diagrama fase-tiempo al ejecutar la siguiente secuencia de instrucciones en el procesador multiciclo: LOAD R4,@M ADD R4,R4,R3 STORE R4,@M

LOAD R4,@M

1

2

3

4

5

F

D

E

M

W

ADD R4,R4,R3 STORE R4,@M

6

7

8

9

F

D

E

W

10

11

12

13

F

D

E

M

11.1 Segmentación básica El objetivo de la segmentación es aumentar el rendimiento del procesador extrayendo paralelismo a nivel de instrucción permitiendo que varias instrucciones puedan ejecutarse en paralelo en el procesador. Esto se consigue desacoplando las fases de ejecución de una instrucción mediante registros de pipeline.

Otra característica de la segmentación es que no existe unidad de control, sino que la información de control de una instrucción avanza con la instrucción a lo largo del procesador. Por otro lado, puesto que las instrucciones en procesador multiciclo no tienen el mismo número de fases, al implementar la segmentación se podría dar el caso de que dos instrucciones intentaran acceder en el mismo ciclo a la misma etapa. Para evitar estos problemas en los procesadores segmentados, todas las instrucciones tienen que pasar por todas las etapas. Por lo tanto en algunas de estas etapas la instrucción puede estar inactiva, como es el

Capítulo 11 Procesadores segmentados

391

caso de la etapa de memoria en las operaciones enteras. Visto lo anterior, el diagrama fasetiempo de la anterior secuencia de instrucciones ejecutada en un procesador segmentado sería:

LOAD R4,@M ADD R6,R5,R3

1

2

3

4

5

F

D

E

M

W

F

D

E

M

W

F

D

E

M

STORE R7,@M

6

7

W

Como se puede observar, esta secuencia tarda 7 ciclos en ejecutarse, mientras que en el multiciclo la misma secuencia tarda 13 ciclos.

11.2 Problemas y soluciones: técnicas básicas En un procesador segmentado ideal el ciclo por instrucción es 1. En los procesadores reales aparecen una serie de riesgos que provocan la parada del procesador y, por lo tanto, la pérdida de rendimiento. Estos riesgos son: Riesgos estructurales. Riesgos de lectura después de escritura (LDE). Riesgos de escritura después de lectura (EDL). Riesgos de escritura después de escritura (EDE). Riesgos estructurales: dos instrucciones intentan acceder en el mismo ciclo de reloj al mismo recurso hardware (HW). Por ejemplo, si una instrucción se encuentra en la etapa de búsqueda y un LOAD se encuentra en la etapa de memoria, las dos intentan acceder a la memoria. Estos riesgos se pueden eliminar parando la segunda instrucción, pero las paradas penalizan el rendimiento. En la mayoría de los casos se pueden eliminar los riesgos añadiendo más HW. En el caso de la memoria se van a utilizar dos memorias, una de instrucciones y otra de datos. Otra optimización HW que evita paradas es permitir que el banco de registros se escriba en la primera mitad del ciclo de reloj y se lea en la segunda mitad del ciclo de reloj. Riesgos de lectura después de escritura, una instrucción intenta leer un dato antes de que haya sido escrito en el banco de registros. Supongamos la secuencia de instrucciones: LOAD R4,@M ADD R6,R4,R3

En el siguiente cuadro puede observarse que la instrucción de LOAD escribe el dato en el ciclo 5, pero que la instrucción ADD lo necesita en el ciclo 3, que es cuando lo tiene que leer del banco de registros. Por lo tanto, si no se hace algo, la instrucción LOAD se ejecutará con un valor erróneo.

392


La solución más sencilla es parar la instrucción ADD hasta que ha acabado el LOAD. Esto soluciona el problema pero penaliza el rendimiento. Darse cuenta que la parada en decodificación provoca la parada de todas las instrucciones que van detrás.

Otra solución es el cortocircuito. La instrucción que proporciona el dato lo envía directamente a la etapa de ejecución de la instrucción que lo espera.

Si la instrucción que proporciona el dato es un LOAD, el estudio es ligeramente diferente porque el dato no se da desde ejecución sino desde memoria, es decir un ciclo más tarde. Por lo tanto hay que provocar una parada además de activar el corto circuito. Es importante darse cuenta que los cortocircuitos reducen las paradas, pero no las eliminan.

Riesgos de control. Las instrucciones de bifurcación tienen que calcular la dirección de salto y comprobar la condición de salto antes de poder leer la siguiente instrucción. Vamos a suponer que las bifurcaciones realizan ese cálculo en la etapa de ejecución:


393

En estos casos hay que provocar dos paradas antes de poder leer la instrucción siguiente. El problema se puede reducir adelantando el HW que calcula la condición y la dirección de salto a la etapa de decodificación:

Con esta aproximación se reducen las paradas pero no se eliminan. Otra solución es utilizar saltos retardados. Esta es una técnica de compilación que consiste en que el compilador busca una instrucción que se ejecute siempre y la coloca detrás del salto condicional. Además, el HW del procesador en lugar de provocar una parada ejecuta esta instrucción, que viene direccionada por el contador de programa

Evidentemente el compilador debe comprobar que al cambiar de posición esta instrucción no se altera el resultado final del programa. Cuando no encuentra una instrucción de estas características el compilador añade una instrucción NOP, que es una instrucción que no hace nada. Se puede considerar equivalente a una parada. Otra solución es la predicción estática. Esta es una solución HW. Por defecto se empieza a ejecutar siempre la instrucción direccionada por el contador del programa. Si la predicción falla esta instrucción se convierte en una NOP y se ejecuta la instrucción correcta. En caso de que acierte la predicción se sigue la ejecución normal. Con esto se consigue que sólo haya paradas en los casos en los que falla la predicción.

394


Existen otros dos tipos de riesgo. Escritura después de escritura en el que una instrucción intenta escribir un dato en una posición del banco de registros antes de que una instrucción anterior haya escrito su resultado en la misma posición del banco de registros. Las soluciones a este tipo de riesgo las explicamos en el epígrafe de procesadores segmentados multifuncionales. El riesgo de escritura después de lectura aparece cuando una instrucción intenta escribir un dato en una posición del banco de registros antes de que una instrucción anterior lo haya leído. Por construcción, no se pueden dar en ninguno de los dos procesadores segmentados que vamos a estudiar.

11.3 Pipeline multifuncional En estos procesadores, además de la unidad funcional de enteros, se tiene un conjunto de unidades funcionales de coma flotante que se caracterizan por tener latencias superiores a 1. Suponiendo una suma en coma flotante con una latencia de 2 ciclos y una multiplicación de 4 ciclos, el diagrama etapa-tiempo de la secuencia de instrucciones: ADD F4,F2,F6 MUL F8,F10,F0

ADD F4,F2,F6 MUL F8,F10,F0

1

2

3

4

F

D

E1 E2

F

D

5

6

M

W

7

E1 E2 E3 E4

8

9

M

W

El estudio realizado para los riesgos de lectura después de escritura y de control es válido para estos procesadores multifuncionales. Debido a que ahora las instrucciones tienen diferente longitud se puede dar el caso de que dos instrucciones intenten escribir en el banco de registros en el mismo ciclo de reloj. Como el banco de registros sólo tiene un puerto de escritura hay que evitarlo. Se puede utilizar un banco de registros con dos puertos de escritura, pero esto es caro y complejo. Hay dos soluciones: a) parar un ciclo de reloj la segunda instrucción en la etapa de decodificación, o b) parar la segunda instrucción en la última etapa de ejecución. Por último, se va a estudiar el tratamiento de los riesgos de escritura después de escritura. En el siguiente cuadro se puede ver un ejemplo. La instrucción de suma debería ser la última en escribir, pero dado que la multiplicación es más larga es la última que lo hace.


MUL F8,F10,F0

1

2

F

D F

ADD F8,F2,F6

3

4

5

7

8

E1 E2 E3 E4

M

W

D

W

E1 E2

6

M

395

9

Existen dos soluciones: a) detener en decodificación la segunda instrucción lanzada o b) inhibir la escritura de la primera instrucción lanzada. Para calcular el ciclo por instrucción de estos procesadores se va a utilizar la siguiente expresión: tipos de instrucción

;

CPI % CPIideal !

i

frecuenciai # penalizacióni

Donde frecuencia indica la frecuencia con la que aparece una determinada penalización. Por ejemplo, si considero que las bifurcaciones condicionales siempre van a producir una parada de dos ciclos y que el 30% de las instrucciones son bifurcaciones, el CPI sería: tipos de instrucción

CPI % CPIideal !

; i

frecuenciai # penalización1 % 1 ! 0,3 # 2 % 1,6

NOTA: instrucciones más usadas en los problemas. N.o de ciclos en ejecución

Instrucción LD Fi,ⲆD(Rb)

Movimiento de información de memoria a registro

1

SD ⲆD(Rb),Fi

Movimiento datos de registro a memoria

ADDD D,Fi,Fj

Suma en coma flotante

Variable

MULD D,Fi.Fj

Multiplicación en coma flotante

Variable

DIVD D,Ri,Rj

División en coma flotante

Variable

ADDI D,Ri,Rj

Suma de enteros

1 ciclo

SUBI D,Ri,Rj

Resta de enteros

1 ciclo

BEQZ Ri,@M

Saltar si Ri % 0

1 ciclo

BNEZ Ri,@M

Saltar si Ri Ç 0

1 ciclo

SGTI Ri, Rj, DONE

Ri % 1 si Rj b DONE

1 ciclo

NOP

Instrucción que introduce el compilador. No hace nada

1 ciclo

1 ciclo

396


11.4 Problemas resueltos PROBLEMA 1 El siguiente fragmento de código se ejecuta en un procesador segmentado: LOOP: LD F2, 0(R1) MULTD F4, F2, F0 LD F6, 0(R2) ADDD F6, F4, F6 SD 0(R2), F6 ADDI R1, R1, 8 ADDI R2, R2, 8 SGTI R3, R1, DONE BEQZ R3, LOOP NOP Suponiendo que: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. La detección de riesgos LDE y parada se realiza en la etapa de decodificación. La detección de riesgos estructurales y parada se realiza en la etapa de decodificación. Los saltos se resuelven en la etapa de decodificación. Se emplea la técnica de compilación salto retardado de una instrucción para reducir las paradas por riesgo de control. Se permite que coexista una STORE y una instrucción aritmético-lógica en la misma etapa. Las unidades funcionales tienen las siguientes características: UF

Cantidad

Latencia

Segmentación

FP ADD

1

4

No

FP MUL

1

5

No

INT ALU

1

1

No

Determinar el CPI teniendo en cuenta que DONE % 0 # 1000 y R1 % 0 # 0100 al inicio de la ejecución y se supone que no se dispone de lógica de cortocircuito. Solución: Recordatorio: SGTI R3, R1, DONE carga un 1 en R3 si R1 b DONE. El dato no se puede tener hasta que se ha escrito en el banco de registros en la etapa de escritura (W o WB del inglés «Write Back»).

SD 0(R2), F6

ADDI R1, R1, 8

ADDI R2, R2, 8

SGTI R3, R1, DONE

BEQZ R3, LOOP

5

6

7

8

9

LD F2, 0(R1)

ADDD F6, F4, F6

4

11

LD F6, 0(R2)

3

NOP

MULTD F4, F2, F0

2

10

LD F2, 0(R1)

1

F

1 E

3

5

M W

4

6

7

8

9

FP FP

F

E

M W

FP FP FP FP FP

FP FP FP FP FP

F

F

D

F DP DP DP DP DP D

F DP DP DP DP DP D E1 E2 E3 E4 M W

D

E

FP

FP

F

F

D

E

M W F DP D

E

M W

M W

M W

F DP D

D

E

E

E

M W

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

F DP DP D E1 E2 E3 E4 E5 M W

D

2


397

398


La parada de las instrucciones en la etapa de búsqueda (FP) se produce porque la instrucción anterior está parada en decodificación (DP). La instrucción número 2 (I2) se para por LDE con 1. La parada se mantiene hasta que la instrucción 1 (I1) alcanza la etapa W, entonces I2 puede leer los registros en la segunda parte del ciclo de reloj y por lo tanto finalizar su etapa de decodificación. Esto es aplicable al resto de los casos. I4 se para por LDE con 2. I5 se para por LDE con 4. I8 se para por LDE con 6. I9 se para por LDE con 8. I11 es la primera instrucción del siguiente ciclo que se ejecuta CPI %

24 Ciclos totales % % 2,66 9 Instrucciones totales

PROBLEMA 2 Sea el procesador y el fragmento de programa del problema anterior. Determinar el CPI suponiendo que se dispone de lógica de cortocircuito. Solución:

1

LD F2, 0(R1)

2

MULTD F4, F2, F0

3

LD F6, 0(R2)

4

ADDD F6, F4, F6

5

SD 0(R2), F6

6

ADDI R1, R1, 8

7

ADDI R2, R2, 8

8

SGTI R3, R1, DONE

9

BEQZ R3, LOOP

10

NOP

11

LD F2, 0(R1)

1

2

3

4

5

F

D

E

M W

6

7

8

9

10 11 12 13 14 15 16 17 18 19 20

F DP D E1 E2 E3 E4 E5 M W F

D

E

M W

F DP DP DP D E1 E2 E3 E4 M W F D P DP D

E

M W

FP FP

D

E

M W

F

D

E

M W

F

D

E

F

M W

F DP D

E

M W

F

D

E

M

F

I2 para en decodificación por una dependencia de LDE con I1. I4 para en decodificación por una dependencia de LDE con I2. I5 para en decodificación por una dependencia LDE con I4. El cortocircuito se produce


399

de la etapa de ejecución de I4 a la etapa de memoria de I5. Esto es posible porque se permite que coexistan un STORE y una instrucción aritmético-lógica en las etapas M y W. Para poder ganar este ciclo además el HW que implementa el STORE tiene que permitir calcular la dirección efectiva de memoria (ciclo 13) sin tener todavía el dato que se quiere enviar a memoria (ciclo 14). I9 para un ciclo debido a la dependencia LDE con I8. Esta parada aparece porque I de bifurcación hace el cálculo de la dirección de salto y de la condición en la etapa de decodificación. Si este cálculo se realizara en la etapa de ejecución esta parada no aparecería. I11 es la primera instrucción que se ejecuta del siguiente bucle, por lo tanto un bucle tarda 17 ciclos en ejecutarse. El total de instrucciones ejecutadas en bucle es 9 (recordar que NOP no cuenta como instrucción). Con estos datos podemos decir que el ciclo por instrucción de este programa es: CPI %

17 # 900 Ciclos totales % % 1,88 9 # 900 Instrucciones totales

En los casos en los que el bucle se repita muchas veces podemos despreciar los ciclos de llenado porque su valor es insignificante. También se puede despreciar si se supone que el programa lleva ejecutándose un rato, puesto que el efecto del llenado del pipeline ya se ha diluido. PROBLEMA 3 El siguiente fragmento de código: LOOP: LD F2, 0(R1) MULTD F4, F2, F0 LD F6, 0(R2) ADDD F6, F4, F6 LD F8, 0(R3) ADDD F6, F8, F6 SD 0(R2), F6 ADDI R1, R1, Ⲇ8 ADDI R2, R2, Ⲇ8 ADDI R3, R3, Ⲇ8 SGTI R4, R1, DONE BEQZ R4, LOOP NOP Se ejecuta en un procesador con segmentación con las siguientes características: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. Se dispone de lógica de cortocircuito a través de los registros de segmentación.

400


Los saltos se resuelven en la etapa de decodificación (el PC se modifica en esta etapa). La detección y parada se hace en decodificación para todos los casos (riesgos LDE y riesgos estructurales). Dos instrucciones no pueden coexistir en la misma etapa. Los riesgos de control se solucionan mediante la técnica de compilación del salto retardado. Las unidades funcionales tienen las siguientes características: UF

Cantidad

FP ADD

Latencia

Segmentación

2

No

FP MUL

1

3

No

INT ALU

1

1

No

a) Construye el diagrama de etapa-ciclo correspondiente a la primera iteración del bucle. b) Determinar el CPI teniendo en cuenta que DONE % 0 # 1000 y R1 % 0 # 0100 al inicio de la ejecución. Solución: a) (Ver tabla de la página siguiente.) Las instrucciones que paran en la etapa F (representado en el diagrama como FP) lo hacen porque la instrucción anterior se encuentra parada en D (representado por DP) y por lo tanto no pueden avanzar. I2 para debido a la LDE con 1. En este caso el cortocircuito se realiza desde la etapa de memoria de I1 a la etapa de ejecución de I2, pasando por el registro del pipeline correspondiente. I4 para por LDE con 2 (produciéndose el cortocircuito desde la etapa de ejecución a la etapa de ejecución) y por LDE con 3 (produciéndose en este caso el cortocircuito de la etapa de memoria a la etapa de ejecución). I5 para en D para evitar un riesgo estructural con I4 en el ciclo 10 (en caso de no parar ambas instrucciones coincidirían en la etapa de memoria). I6 para en D por LDE con 5. I7 para en D por LDE con 6. En este caso se ha supuesto que I de STORE no empieza a calcular la dirección efectiva hasta que tiene tanto el valor del registro entero que usa para calcular la dirección efectiva, como el valor que quiere llevar a memoria. I8 tiene dos paradas en la etapa de decodificación. La primera para evitar un riesgo estructural con I6 y la siguiente para evitar un riesgo estructural con I7, ambas en la etapa de memoria. I12 para debido a un riesgo LDE con 11. En este caso hay que recordar que el cálculo de la dirección de salto y de la condición se realiza en la etapa de decodificación, por eso se tiene que parar hasta que se tiene el valor de R4 necesario para el cálculo de la condición. I14 es la primera que se ejecuta del siguiente bucle.

LD F2, 0(R1)

MULTD F4, F2, F0

LD F6, 0(R2)

ADDD F6, F4, F6

LD F8, 0(R3)

ADDD F6, F8, F6

SD 0(R2), F6

ADDI R1, R1, 8

ADDI R2, R2, 8

ADDI R3, R3, 8

SGTI R4, R1, DONE

BEQZ R4, LOOP

NOP

LD F2, 0(R1)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

F

1 E

3

5

M W

4

6

7

8

9

FP

F

E

M W

FP FP

E

M W

FP

E

FP FP

F

F DP DP D

F DP D

F

D

E

F

D

E

E

FP

F

F

D

E

M W

M W

F DP D

D

E

M W

M W

M W

F DP D E1 E2 M W

F DP D

D

E

E

M W

M W

M W

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

F DP D E1 E2 M W

D

F DP D E1 E2 E3 M W

D

2


401

402


b) Número de instrucciones en un bucle: 12 (recordar que NOP no se considera instrucción). Número de ciclos: 19. Como el bucle se ejecuta 900 veces suponemos que los ciclos de llenado se pueden despreciar: 19 Ciclos totales % % 1,583 CPI % Instrucciones totales 12 PROBLEMA 4 Sea un procesador segmentado multiciclo con las siguientes características: Un dato se puede escribir y leer de un registro en el mismo ciclo de reloj. Los saltos se resuelven en la etapa de decodificación. Las detecciones de riesgos de datos y generación de paradas se realizan en la etapa de decodificación. La detección de riesgos EDE se realiza en la etapa de decodificación. Se soluciona con una parada hasta que la instrucción ya lanzada entre a la etapa de memoria. Lógica de cortocircuito. Los riesgos de control se solucionan mediante compilación usando la técnica del salto retardado de 1 instrucción. No pueden coincidir dos instrucciones en las mismas etapas. Se resuelve con detección y parada de la segunda instrucción en la etapa de decodificación. Unidad de ejecución multiciclo con los siguientes ciclos de ejecución: UF

Cantidad

Latencia

Segmentación

FP ADD

1

2

No

FP DIV

1

5

No

FP MUL

1

4

No

INT ALU

1

1

No

Y el siguiente fragmento de código: LOOP: LD F6, 0(R2) MULD F8,F6,F0 ADDI R2,R2,Ⲇ1 LD F2, 0(R2) DIVD F8,F2,F8 SD 0(R2), F8 MULD F8,F2,F0


403

ADD F8,F4,F6 ADDI R3,R3,,Ⲇ8 SGTI R4,R3,DONE BNEZ R4,LOOP NOP a) CPI del pipeline, suponiendo que el bucle se ejecuta muchas veces. b) El hardware de la máquina puede inhibir la escritura en el registro destino de una instrucción ya lanzada. Explica cómo usar esta característica para reducir las penalizaciones debidas a los riesgos EDE. Calcula el nuevo valor de CPI. Solución: a) (Ver tabla de la página siguiente.) Las instrucciones con parada en F (FP) lo están porque la instrucción anterior está parada en D (DP). I2 para por LDE con 1. El cortocircuito se realiza desde la etapa de memoria del LOAD a la etapa de ejecución de MULD. I5 para por LDE con 4 y con 2. I6 para por LDE con 5. En este caso hemos supuesto que I de STORE no empieza a calcular la dirección efectiva hasta que tiene tanto el valor del registro entero que usa para calcular la dirección efectiva, como el valor que quiere llevar a memoria. I8 para por EDE con 7. Esta dependencia puede aparecer por modificaciones que hace el compilador en el programa. I11 para por LDE con 10. Esta parada aparece porque I de bifurcación calcula la dirección de salto y la condición en la etapa de decodificación y necesita el valor de R4 para calcular la condición. Esta parada se podría eliminar mediante cortocircuito combinacional es decir que I10 mandara el valor de R4 a I11 directamente, es decir sin pasar por el registro de pipeline correspondiente. I13 corresponde a la primera instrucción ejecutada del siguiente ciclo. Total de instrucciones ejecutadas: 11 (recordar que NOP no se cuenta como instrucción). Total de ciclos: 22. Despreciando los ciclos de llenado el CPI es CPI %

Ciclos totales 22 % %2 Instrucciones totales 11

b) (Ver tabla de la página 405). Las instrucciones paradas en F (FP) lo están porque la instrucción anterior está parada en D (DP) y eso para todo el pipeline. I2 para por LDE con 1. I5 para por LDE con 4 y 2.

ADDI R3,R3,Ⲇ8

9

LD F6,0(R2)

ADDD F8,F4,F6

8

13

MULD F8,F2,F0

7

NOP

SD 0(R2),F8

6

12

DIVD F8,F2,F8

5

BNEZ R4,LOOP

LD F2,0(R2)

4

11

ADDI R2,R32,Ⲇ1

3

SGTI R4,R3,DONE

MULD F8,F6,F0

2

10

LD F6,0(R2)

1

F

1 E

3

5

M W

4

6

7

8

9

FP

F F

D E

M W

M W

FP FP FP FP FP

F

F DP DP DP DP D

M W

FP FP

F

F DP D

E

FP

F

F

D

E

M W

M W

F DP D

D

E

F DP DP D E1 E2 M W

D E1 E2 E3 E4 M W

E

F DP D E1 E2 E3 E4 E5 M W

D

E

D

E

E

M

M W

M W

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

F DP D E1 E2 E3 E4 M W

D

2

404 Problemas de fundamentos y estructura de computadores

ADDI R3,R3,Ⲇ8

9

LD F6,0(R2)

ADDD F8,F4,F6

8

13

MULD F8,F2,F0

7

NOP

SD 0(R2),F8

6

12

DIVD F8,F2,F8

5

BNEZ R4,LOOP

LD F2,0(R2)

4

11

ADDI R2,R32,Ⲇ1

3

SGTI R4,R3,DONE

MULD F8,F6,F0

2

10

LD F6,0(R2)

1

F

1 E

3

5

M W

4

6

7

8

9

FP

F F

D E

M W

M W

FP FP FP FP FP

F

F DP DP DP DP D

M W

F

FP FP

F

F DP D P D

E

FP

F

F

D

E

M W

M W

F DP D

D

E

D E1 E2 M W

D E1 E2 E3 E4 M NW

E


D

E

E

M W

M W

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

F DP D E1 E2 E3 E4 M W

D

2


405

406


I6 para por LDE con 5. I7 inhibe su escritura para evitar riesgos EDE. Como consecuencia I8 tienes menos ciclos de parada. I9 tiene dos paradas, la primera para evitar que accedan la 8 y la 9 en el mismo ciclo de reloj a la etapa m, el segunda para evitar que 7 y 9 accedan en el mismo ciclo de ck a la etapa M. I11 para por LDE con 10. Recordar que los saltos se resuelven en decodificación. Total de instrucciones: 11, Total de ciclos: 21. CPI %

21 Ciclos totales % % 1,9 Instrucciones totales 11

PROBLEMA 5 Supongamos un procesador segmentado en cinco etapas que posee anticipación de operandos y utiliza saltos retardados con un «delay-slot» de un ciclo, pero que posee una sola memoria cache para el almacenamiento de instrucciones y datos. Por esta razón no resulta posible leer una instrucción y realizar la lectura o escritura de un dato en el mismo ciclo de reloj. Suponemos que el HW que detecta el riesgo estructural en la memoria está en la etapa de búsqueda (F). Las escrituras en el banco de registros se hacen en la primera mitad de la fase W, mientras que las lecturas se hacen en la segunda mitad de la fase W. Supongamos que este procesador ejecuta el siguiente programa: bucle:

LW

R2,X(R6)

LW

R3,Y(R6)

SUB

R2,R2,R3

ADD

R2,R2,R1

SUB

R6,R6,Ⲇ4

SW

Z(R6),R2

BNEZ R6,bucle ADD

R1,R1,Ⲇ1

SUB

R3,R3,R7

Siendo el valor inicial de R6 2000. a) Construye el diagrama fase-ciclo correspondiente a la primera iteración del bucle indicando los cortocircuitos que se activan. b) Calcula el valor del CPI. c)

Si el computador trabaja con una frecuencia de 1 GHz, determina el rendimiento en MIPS.


407

Solución: a)

1

2

3

4

5

F

D

E

M W

F

D

E

6

7

8

9

10 11 12 13 14 15 16

1

LW R2,X(R6)

2

LW R3,Y(R6)

3

SUB R2,R2,R3

F DP D

E

M W

4

ADD R2,R2,R1

FP FP

F

D

E

M W

5

SUB R6,R6,Ⲇ4

F

D

E

M W

6

SW Z(R6),R2

F

D

E

M W

7

BNEZ R6, BUCLE

F

D

E

M W

8

ADD R1,R1,Ⲇ1

F

D

E

M W

9

LW R2,X(R6)

FP

F

D

M W

E

M WB

NOTA: no siempre que coincide una etapa de memoria con una de búsqueda se produce una parada. Sólo cuando la etapa de memoria pertenece a una instrucción que hace uso de la memoria, es decir LOAD y STOREs. Estas etapas de memoria están marcadas en gris. I3 para por LDE con I2. En este caso el cortocircuito se produce desde la etapa de memoria de I2 a la etapa de ejecución de I3. I4 tiene que parar dos ciclos en la etapa de búsqueda por riesgo estructural, primero con I4 y luego con I5. I9, que es la primera que se ejecuta del siguiente ciclo, tiene que parar por riesgo estructural con I6. b) Total de ciclos 11. Total de instrucciones: 8. CPI % c)

Ciclos totales 11 % % 1,375 Instrucciones totales 8

R6 es el registro que controla el bucle. Inicialmente tiene cargado el valor 2000 y se decrementa de 4 en 4, luego el bucle se ejecuta 2000/4 % 500 veces. Instrucciones totales % 8 por bucle # 500 bucles % 4.000 Ciclos totales % 11 por bucle # 500 bucles % 5.500 Tiempo total % Ciclos totales # Tiempo ciclo % %

MIPS %

Ciclos totales % Frecuencia

5.500 ciclos % 5,5 . 10.6 s 109 Hz

Instrucciones ejecutadas . 10.6 4.000 . 10.6 % % 727,3 MIPS Tiempo total 5,5 . 10.6

408


PROBLEMA 6 Sea un procesador segmentado con las siguientes características: Un dato se lee y se escribe en el banco de registros en el mismo ciclo de reloj. La etapa de ejecución es multiciclo y consta de 1 sumador/restador de coma flotante segmentado en 2 etapas, 1 multiplicador de coma flotante segmentado en 5 etapas y 1 unidad de enteros. Las dependencias de LDE se detectan en la primera etapa de cada unidad funcional y se resuelven mediante cortocircuito cuando los operandos están disponibles. Los riesgos estructurales se detectan y se resuelven mediante espera en la última etapa de cada unidad funcional. Los riesgos de EDE entre dos instrucciones A y B tal que A precede a B se resuelven mediante inhibición de escritura de la instrucción A. Sabiendo que se ejecuta el siguiente código: LD F10,0(R1) MULD F4,F0,F10 LD F12,0(R2) ADD F2,F12,F4 LD F4 8(R1) MULD F12, F4, F12 LD F14,16(R1) a) Construye el diagrama fase-ciclo de reloj. Explica detalladamente en cada caso la causa de cualquier posible riesgo y cualquier posible parada. b) ¿Que ventaja tiene la detección y parada en la primera etapa de ejecución frente a la detección y parada en decodificación? Solución: a) 1

LD F10,0(R1)

2

MULD F4,F0,F10

3

LD F12,0(R2)

4

ADD F2,F12,F4

5

LD F4 8(R1)

6

MULD F12,F4,F12

7

LD F14,16(R1)

1

2

3

4

5

F

D

E

M

W

F

D X1P X1 X2 X3 X4 X5 F

10

11

M

NW

D

E

F

D A1P A1P A1P A1P A1

A2

F

6

M

7

8

9

12 13 14 15

W

M

M W

D

E

F

D X1P X1 X2

X3 X4 X5 M W

F

M

D

W

EP

E

W


409

I2 tiene un riesgo LDE con la 1, por lo tanto se produce una parada en la primera etapa de ejecución de la multiplicación. Además se inhibe la escritura para eliminar el riesgo EDE con I5. I4 tiene 4 paradas para evitar el riesgo LDE con I2. I6 tiene una parada para evitar el riesgo LDE con I5. I7 parada para evitar el riesgo estructural con I2 (ambas intentan acceder a memoria en el ciclo 10). Esta parada puede eliminarse si se especifica que una instrucción de memoria y otra aritmético-lógica pueden estar simultáneamente en memoria puesto que sólo una de ellas accede a memoria. b) Al producirse las paradas en la primera etapa de ejecución, el procesador no para puesto que puede seguir leyendo, decodificando y mandando instrucciones a otras unidades funcionales no ocupadas. Sólo cuando se envía una instrucción a la unidad funcional parada se para todo el procesador. Vamos a hallar la tabla para este segundo caso para comparar CPI:

1

LD F10,0(R1)

2

MULD F4,F0,F10

3

LD F12,0(R2)

4

ADD F2,F12,F4

5

LD F4 8(R1)

6

MULD F12,F4,F12

7

LD F14,16(R1)

1

2

3

4

5

F

D

E

M W

6

7

8

9

10 11 12 13 14 15 16 17 18 19 20

F DP D E1 E2 E3 E4 E5 M W FP

F

D

E

M W

F DP DP DP D E1 E2 M W FP FP FP

F DP D FP

E

M W

F DP D E1 E2 E3 E4 E5 M W F

D

E

M W

Las instrucciones que paran en F (FP) lo hacen porque la instrucción anterior está parada en D (DP), es decir una parada en D produce la parada del procesador, lo que quiere decir que se dejan de buscar instrucciones. I2 para debido a una dependencia de LDE con I1. Podemos observar que en este caso no hace falta inhibir la escritura de esta instrucción puesto que ha desaparecido el riesgo EDE con I5. I4 para debido a un riesgo de LDE con I2. I5 tiene una parada en decodificador para evitar un riesgo estructural con I4, puesto que las dos intentan acceder a la etapa de memoria en el ciclo 12. I6 para en decodificación (DP) para evitar un riesgo de LDE con I5. N.o de instrucciones ejecutadas en ambos casos: 7. N.o de ciclos del primer caso desde que se lanza la primera instrucción hasta que acaba de ejecutarse: 15. CPI %

15 Ciclos totales % % 2,14 7 Instrucciones totales

410


N.o de ciclos del segundo caso desde que se lanza la primera instrucción hasta que acaba de ejecutarse: 20 20 Ciclos totales CPI % % % 2,857 7 Instrucciones totales Por otro lado, la opción inicial es más compleja de implementar puesto que tiene que existir una lógica de detección y parada para cada una de las primeras etapas de las unidades de ejecución. PROBLEMA 7 El siguiente fragmento de código se ejecuta en un procesador segmentado: LOOP: LD F2, 0(R1) MULTD F4, F2, F0 LD F6, 0(R2) ADDD F6, F4, F6 LD F8, 0(R3) ADDD F6, F8, F6 SD 0(R2), F6 ADDI R1, R1, 8 ADDI R2, R2, 8 ADDI R3, R3, 8 SGTI R4, R1, DONE BEQZ R4, LOOP NOP Suponiendo que: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. Sólo se dispone de lógica de cortocircuito a través de registros de segmentación de la etapa de memoria a la etapa de ejecución. Los saltos se resuelven en la etapa de decodificación. Se está empleando salto retardado para eliminar las paradas por riesgo de control. Las unidades funcionales tienen las siguientes características: Cantidad

N.o ciclos

Segmentación

FP ADD

1

4

No

FP MUL

1

5

No

INT ALU

1

1

No

UF

Determinar el CPI teniendo en cuenta que DONE % 0 # 1000 y R1 % 0 # 0100 al inicio de la ejecución y explica cuál es el efecto de este tipo de cortocircuito. Solución:

14 LD F2, 0(R1)

13 NOP

12 BEQZ R4, LOOP

11 SGTI R4, R1, DONE

10 ADDI R3, R3, 8

9 ADDI R2, R2, 8

8 ADDI R1, R1, 8

7 SD 0(R2), F6

6 ADDD F6, F8, F6

5 LD F8, 0(R3)

4 ADDD F6, F4, F6

3 LD F6, 0(R2)

2 MULTD F4, F2, F0

1 LD F2, 0(R1)

3

5

M W

4

6

7

8

FP F

E

M W

FP FP FP FP F

E

M W

FP FP FP FP F

FP FP FP F DP DP DP DP D

F

D

E

F DP DP DP D E1 E2 E3 E4 M W

D

F DP DP DP DP D E1 E2 E3 E4 M W

D

F

D

E

F

D

E

E

M W

M W

F

F D E M

F DP DP D E M W

D

E

M W

M W

M W

9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30


F D E

1 2


411

412


Las instrucciones que paran en la etapa de búsqueda (FP) lo hacen porque la instrucción anterior está parada en la etapa de decodificación (DP). I2 para debido a la dependencia de LDE con I1. Fijarse que entre I3 y I4 no aparece un riesgo de EDE aunque los dos escriben sobre el mismo registro. Esto se debe a que I3 es más corta que I4 y por lo tanto el riesgo desaparece, pero aun en el caso que I3 fuera más larga que la 4 no habría riesgo puesto que entre 3 y 4 hay una dependencia de LDE y esto deshace los riesgos de EDE. I4 tiene paradas por la dependencia de LDE con I2. Recuerda que el único cortocircuito que existe es de la etapa de memoria a la etapa de ejecución. Esta es la razón por la que la parada dura un ciclo más. I6 para por dependencia de LDE con I4. I7 para debido a su dependencia LDE con I6. En este caso se supone que STORE espera a tener todos los valores que necesita para empezar a ejecutarse. I12 tiene dos paradas, puesto que necesita el valor del registro R4 para calcular la condición de salto, y este valor sólo se le puede pasar desde la etapa de memoria de la instrucción anterior. La última instrucción, en gris, corresponde a la ejecución del siguiente bucle. CPI %

27 Ciclos totales % % 2,25 Instrucciones totales 12

En general, se puede decir que para todas las dependencias LDE aparece una parada más puesto que el dato se envía un ciclo más tarde. En el caso del LOAD el número de paradas se mantiene puesto que el dato se sigue enviando desde la etapa de memoria. PROBLEMA 8 Imagina el procesador del problema anterior pero con cortocircuito sólo desde la etapa de ejecución a la etapa de ejecución. Determinar el CPI teniendo en cuenta que DONE % 0 # 1000 y R1 % 0 # 0100 al inicio de la ejecución. Explica cuál es el efecto de este tipo de cortocircuito. Solución: Si sólo hay cortocircuito de ejecución a ejecución, las instrucciones de LOAD no pueden entregar un dato a la etapa de ejecución desde la etapa de memoria. Por lo tanto, la instrucción dependiente tiene que esperar en decodificación hasta que LOAD llega a la etapa de escritura (ver tabla de página siguiente). I2 para en decodificación hasta que la I1 ha escrito en el banco de registros y puede leer el dato. Esta lectura se realiza en el mismo ciclo de reloj que la escritura. I4 para hasta el ciclo 10 porque además de la dependencia con el LOAD tiene dependencia con I2.

LD F2, 0(R1)

MULTD F4, F2, F0

LD F6, 0(R2)

ADDD F6, F4, F6

LD F8, 0(R3)

ADDD F6, F8, F6

SD 0(R2), F6

ADDI R1, R1, 8

ADDI R2, R2, 8

ADDI R3, R3, 8

SGTI R4, R1, DONE

BEQZ R4, LOOP

NOP

LD F2, 0(R1)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

F

1 E

3

5

M W

4

6

7

8

9

F

D

M W

F

E

M W

F

F DP DP DP D

F

D

E

F

D

E

F

D

E

E

M W

M W

FP FP

F

F DP DP D

D

E

M W

M W

M W

F DP DP D E1 E2 E3 E4 M W

D

F DP DP DP D E1 E2 E3 E4 M W

E

F

D

E

E

M

10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

F DP DP D E1 E2 E3 E4 E5 M W

D

2


413

414


I6 para por las dos dependencias con las instrucciones 5 y 4 que se resuelven en el mismo ciclo de reloj. I7 para por la dependencia con I6. Suponemos la instrucciones de STORE no inician el cálculo de su dirección efectiva hasta que tiene todos los datos para ejecutarse. I12 para porque tiene una dependencia de LDE con la 11 CPI %

Ciclos totales 25 % % 2,08 Instrucciones totales 12

PROBLEMA 9 Supongamos un procesador en el que los accesos a la memoria cache de datos y cache de instrucciones se han segmentado en dos etapas. La detección y paradas por riesgo LDE y EDE se realizan en decodificación. La resolución del salto se realiza en decodificación. El procesador utiliza la técnica de compilación del salto retardado para evitar las paradas por riesgos de control. Sabiendo que la multiplicación en coma flotante se ejecuta en 7 ciclos y la suma en coma flotante en tres, si el procesador ejecuta el siguiente programa: LOAD F2,0(R1) LOOP: MULD F4, F2, F0 ADDD F6, F4,F2 SUBI R1,R1,Ⲇ8 BNZ LOOP LOAD F2,0(R1) LOAD F4 Calcular el diagrama fase-ciclo para la ejecución del último bucle. Solución: El LOAD después de la BNZ es la instrucción que el compilador utiliza para rellenar el delay slot del salto condicional. Por otro lado, si queremos ver cómo se ejecuta el último bucle no es suficiente ver cómo se comportan las instrucciones desde la MULT, puesto que esta instrucción tiene una dependencia LDE con la instrucción LOAD F2,0(R1) que se acaba de ejecutar. Teniendo esto en cuenta el diagrama que queda es el que se muestra en la tabla de la página siguiente. Es importante darse cuenta de dos cosas. El comportamiento del pipeline es idéntico a los ya vistos. Las paradas se producen en la etapa de decodificación y esas paradas se transmiten a todas las etapas anteriores (F2 y F1) parándolas también. Las paradas por LDE serán mayores debido a que el pipeline es más profundo. I1 (en gris) corresponde a la ejecución del penúltimo bucle, es decir del último salto que se toma. Es necesaria ponerla porque I2 tiene que parar debido a la dependencia de LDE con ella.

LOAD F2,0(R1)

MULD F4, F2, F0

ADDD F6, F4,F2

SUBI R1,R1,Ⲇ8

BNZ R1, LOOP

LOAD F2,0(R1)

LOAD

1

2

3

4

5

6

7

2

3

5

6

7

E M1 M2 W

4

8

9

10 11 12 13 14 15 16 17 18 19 20 21 22 23

E M1 M2 W

E M1 M2 W F4 F1 F2 D

F1 F2P F2 D

E M1 M2 W

E M1 M2 W

F1P F1P F1P F1P F1P F1P F1P F1 F2 DP D

F1P F1P F1 F2P F2P F2P F2P F2P F2P F2P F2 D

F1 F2P F2P F2 DP DP DP DP DP DP DP D E1 E2 E3 M1 M2 W

F1 F2 DP DP D E1 E2 E3 E3 E4 E5 E6 E7 M1 M2 W

F1 F2 D

1


415

416


I2 para debido a una dependencia LDE con I1. En este caso el cortocircuito se realiza desde la etapa M2 a la etapa E, por eso hay dos ciclos de parada. I3 para en F2 porque I2 está parada en D. Además, para en D por una dependencia de LDE con 2. I4 para en F1 porque la 3 está parada en F2, y para en F2 porque I3 está parada en D. I5 para en F1 porque la 4 está parada en F2 y para en D porque tiene una dependencia de LDE con 4. I6 para en F2 porque la 5 está parada en D. PROBLEMA 10 Sea un procesador segmentado multifuncional en el que hay un 20% de riesgos de LDE, un 5% de riesgos de escritura después de escritura. Sabiendo que los riesgos de LDE tienen como media 3 ciclos de penalización y que los riesgos de EDE se eliminan inhabilitando la escritura de la primera instrucción, ¿cuál es el CPI de este procesador? Solución: tipos de instrucción

CPI % CPIideal !

;


i

La inhibición de escritura no produce penalización, por lo tanto la única penalización que existe es la debida a los riesgos de LDE, luego el ciclo por instrucción será: CPI % 1 ! 0,20 # 3 % 1,6 PROBLEMA 11 Supongamos un procesador segmentado de cinco etapas en el que se ejecutan 2 aplicaciones diferentes. La aplicación A tiene un 10% de instrucciones con una penalización de 1 ciclo de reloj y un 5% de instrucciones con una penalización de 2 ciclos de reloj. La aplicación B tiene un 15% de instrucciones con 1 ciclo de penalización. a) ¿Cuál es el ciclo por instrucción de cada una de las aplicaciones? b) ¿Cuál es el ciclo por instrucción promedio del procesador? Solución: a) tipos de instrucción

CPI % CPIideal !

; i


CPIA % 1 ! 0,1 # 1 ! 0,05 # 2 % 1,2 CPIB % 1 ! 0,15 # 1 % 1,15


417

b) CPIMEDIO %

1,2 ! 1,15 % 1,175 2

PROBLEMA 12 Supongamos el procesador del problema anterior. a) ¿Cuál es el SPEEDUP del procesador segmentado frente al procesador sin segmentar? b) ¿Cuál es la eficacia del procesador segmentado real frente al procesador segmentado ideal? Solución: a) Vamos a suponer que el tiempo de ciclo es el mismo en las dos aproximaciones. Sabiendo que el SPEEDUP es el tiempo de ejecución en la máquina primitiva partido por el tiempo de ejecución en la que se han metido las modificaciones, el SPEEDUP del procesador segmentado frente al procesador multiciclo es el siguiente: N.o instrucciones # CPI 5 TIEMPOSIN SEGMENTAR % o % % 4,25 SPEEDUP % N. instrucciones X # CPI 1,175 TIEMPOSEGMENTADO b) La eficiencia trata de medir lo que se acerca el procesador real al ideal. Es una medida que se encuentra comprendida entre 0 y 1, cuanto más cerca esté del 1 mayor será la eficiencia: 1 Tiempo cpuideal % % 0,85 Eficiencia % Tiempo cpureal 1,175 PROBLEMA 13 Sea un procesador segmentado en cinco etapas. Ejecutamos en este procesador una aplicación con las siguientes características: El 15% de las veces, las instrucciones Ii!1 tienen una dependencia de LDE con las instrucciones Ii. El 50 %de éstas corresponden a instrucciones de LOAD. El 3% de las veces las instrucciones Ii!2 tienen dependencias de LDE con la instrucción Ii. El 30% de las instrucciones son de bifurcación condicional, de las cuales se toman el 25%. Calcular los ciclos por instrucción del procesador para las siguientes características de procesador: a) Procesador sin técnicas para reducir o eliminar paradas. Los saltos se resuelven en ejecución. Se puede escribir y leer el registro en el mismo ciclo de reloj. b) Procesador con cortocircuito. Los saltos se resuelven en decodificación. c)

Los saltos se resuelven en decodificación y se supone un HW de predicción estática siempre no tomado.

418


Solución: a) Vamos a ver las paradas por dependencias que ocurren en cada caso: Paradas por dependencia entre Ii!1 e Ii Ii

F

Ii!1

D

E

M

W

F

DP DP

D

E

M

W

El número de paradas es 2. En este primer caso los LOAD y el resto de las instrucciones con dependencia tienen el mismo número de paradas puesto que en todos los casos tenemos que esperar hasta la etapa de escritura para poder leer el nuevo valor. Paradas por dependencias entre Ii!2 e Ii Ii

F

Ii!1

D

E

M

W

F

D

E

M

W

F

DP

D

E

Ii!2

M

W

En este segundo caso se produce un ciclo de parada entre Ii e Ii!2. Paradas por bifurcación condicional BC

F

Ii!1

D

E

M

W

FP

FP

F

D

E

M

W

Dos ciclos de parada Por lo tanto el CPI de este procesador será: tipos de instrucción

;

CPI % CPIideal !


i

CPI % 1 ! 0,15 # 2 ! 0,03 # 1 ! 0,3 # 2 % 1,9 CPI b) Procesador con cortocircuito y los saltos se resuelven en decodificación. Como hay cortocircuito, sólo las instrucciones que dependan de un LOAD pararán por LDE. LOAD

F

Ii!1

D

E

M

W

F

DP

D

E

M

W

Como el cálculo de la dirección y de la condición se realiza en decodificación sólo se produce un ciclo de parada. BC Ii!1

F

D

E

M

W

FP

F

D

E

M

W


419

En este caso sólo producen parada por LDE las instrucciones que dependen del LOAD: Instrucciones que dependen del LOAD % 0,5 # 0,15 % 0,075 CPI % 1 ! 0,075 # 1 ! 0,3 # 1 % 1,375 c)

Los saltos se resuelven en decodificación y se supone un HW de predicción estática siempre no tomado. En este caso sólo hay que evaluar la penalización por los saltos en los que falla la predicción. Como la predicción es no tomado, la penalización se produce cuando los fallos se toman, es decir en el 25% de los saltos. Como el 30% son saltos entonces: CPI % 1 ! 0,075 # 1 ! 0,3 # 0,25 # 1 % 1,15

PROBLEMA 14 Sea un procesador segmentado de cinco etapas que tiene el HW para la detección de riesgo y generación de la parada en decodificación. La resolución de los saltos condicionales se realiza en decodificación. Los riesgos de control se resuelven mediante paradas en decodificación, y tiene implementada la técnica de cortocircuito. Supongamos que en este procesador las etapas de ejecución y memoria se unen. Como consecuencia el ciclo de reloj aumenta un 30%. Hallar la relación de velocidades entre la versión original del procesador y la modificada. Supóngase que en el 15% de los casos existen dependencias LDE entre un LOAD y la instrucción que le sigue y que el 23% son saltos condicionales. Solución: Primero vamos a ver los efectos de unir las etapas de ejecución y de memoria. Las dependencias entre dos operaciones aritméticas no producen paradas debido al cortocircuito. Ii

F

Ii!1

D F

EM W D

EM W

Las dependencias entre una instrucción LOAD y una aritmético-lógica no producen paradas, puesto que, debido a que se han unido ejecución y memoria, el dato ya no se entrega un ciclo tarde. LOAD

F

Ii!1

D F

EM W D

EM W

Las instrucciones de salto no se ven afectadas por este cambio, por lo tanto se produce una parada de 1 ciclo. BIFURCA Ii!1

F

D FP

EM W F

D

EM W

420


Vamos a ver cuál sería el CPI medio en los dos casos: CPI % 1 ! 0,15 # 1 ! 0,23 # 1 % 1,38 CPI % 1 ! 0,23 # 1 % 1,23 Con esta información parece que la segunda implementación es mejor. Pero tenemos que tener en cuenta que los tiempos de ciclo son diferentes. Si suponemos Tc–inicial % n el Tc–nuevo % 1,3n Tiempo total 1.o % N # CPI # Tc % N # 1,38 # n % 1,38 . N . n Tiempo total 2.o % N # CPI # Tc % N # 1,23 # 1,3n % 1,599 . N . n Speedup %

1,38 % 0,83 1,599

PROBLEMA 15 Sean dos procesadores segmentados de 5 etapas. Uno de ellos realiza el cálculo de la dirección efectiva y de la condición de salto en la etapa de decodificación, el otro lo hace en la etapa de ejecución, siendo en este caso la frecuencia de reloj un 15% más rápida. En ambos casos vamos a utilizar el salto retardado para resolver los riesgos de control. El compilador que utilizamos genera un 30% de bifurcaciones condicionales. El comportamiento del compilador es el siguiente: El 20% de los casos no encuentra instrucciones para colocar detrás del salto retardado y por lo tanto coloca no operaciones. El 45% de los casos encuentra una instrucción para ocupar el branch delay slot de la bifurcación condicional. El 35% de los casos encuentra dos instrucciones para ocupar el branch delay slot de la bifurcación condicional. Sabiendo que el ciclo por instrucción de ambas implementaciones es el mismo, indica cuál sería la mejor opción. Solución: En el primer caso, el delay slot es de una instrucción (en gris la etapa en la que se hace el cálculo de la dirección y de la condición de salto): BIF

F

Ii!1

D

E

M

W

FP

F

D

E

M

W

En el segundo caso, el delay slot es de 2 instrucciones (en gris la etapa en la que se hace el cálculo de la dirección y de la condición de salto): BIF Ii!1

F

D

E

M

W

FP

FP

F

D

E

M

W


421

Tiempo de CPU cuando la resolución del salto se realiza en decodificación. Como sólo tiene un delay slot, el 20% de los casos el compilador no encuentra una instrucción para colocar detrás de la bifurcación y coloca una NOP, que se considera una penalización de 1 ciclo. Para el resto de los casos encuentra 1 o 2 instrucciones que son suficientes para llenar el delay slot. Por lo tanto, sólo tiene penalización en el caso de las NOP. Su ciclo por instrucción es el siguiente: CPID % 1 ! 0,3 # 0,2 % 1,06 Suponiendo que ejecuta un programa de N instrucciones y que el tiempo de ciclo es Tdecodificación el tiempo de ejecución total del programa es: TCPUdecodificación % 1,06 # N # Tdecodificación Tiempo de CPU cuando la resolución del salto se realiza en ejecución. En este caso el delay slot es de 2, por lo tanto ocurre lo siguiente: para el 35% de los saltos el compilador encuentra dos instrucciones, luego estos casos no tienen penalización. El 45% de los casos encuentra sólo una instrucción, luego en estos casos tendrá un 1 ciclo de penalización, porque el otro slot tendrá que llenarlo con una NOP. El 20% de los casos no encuentra instrucciones, luego mete dos NOP y esto da lugar a dos ciclos de penalización. El CPI en este caso es: CPIE % 1 ! 0,3 # (0,45 # 1 ! 0,2 # 2) % 1 ! 0,3 # 0,85 % 1,255 El tiempo de ejecución (TCPUejecución) de un programa con N instrucciones es: TCPUejecución % 1,255 # N # Tejecución Por otro lado, como la frecuencia del procesador con la resolución de saltos en la etapa de ejecución ( fejecución) es un 15% más rápida que la frecuencia de un procesador con la resolución de saltos en la etapa de decodificación ( fdecodificación) podemos decir lo siguiente: fejecución % 1,15 # fdecodificación r Tdecodificación % 1,15 # Tejecución Sustituyendo este valor en TCPUdecodificación TCPUdecodificación % 1,06 # N # Tdecodificación % 1,06 # N # 1,15 # Tejecución % 1,219 # N # Tejecución PROBLEMA 16 Un computador tiene su ciclo de instrucción segmentado en 4 etapas; F: Búsqueda de la instrucción, D/E: Decodificación de la instrucción, lectura de registros y ejecución en la UAL, M: Acceso a memoria (LOAD y STORE), escritura del PC (Saltos) o vacía (resto), W: Escritura de registros. El computador posee arquitectura con memorias de instrucciones y datos separadas, los riesgos por dependencias de datos los resuelve mediante la técnica del «cortocircuito», y los riesgos por dependencias de control mediante la técnica del salto retardado. Dada la secuencia de instrucciones siguiente, dibuja un diagrama que indique, para cada ciclo de reloj, qué instrucción y fase de la instrucción se está ejecutando:

422


LOOP: LD R1,0(R3) ADD R2,R4,R1 AND R5,R2,R4 BNEZ R2,loop suponemos que R2 ab 0 SW 0(R2),R5 ADD R4,R4,Ⲇ8 LD R1,24(R3) Solución: Tal y como indica el enunciado se utiliza el salto retardado para evitar paradas por riesgos de control. Como el nuevo PC se escribe en la etapa de memoria, hasta el siguiente ciclo no se puede hacer la búsqueda como se ve en el siguiente diagrama: BIF condicional

F D/E M

W

FP

F

I siguiente

FP

Por lo tanto el delay slot es de dos instrucciones. Sabiendo esto el diagrama fase-ciclo es:

1

LD R1,0(R3)

2

ADD R2,R4,R1

3

AND R5,R2,R4

4

BNEZ R2,SALTO

5

SW 0(R2),R5

6

ADD R4,R4,Á

7

LD R1,0(R3)

1

2

3

4

F

D/E

M

W

F

5

6

M

W

D/E

M

W

F

D/E

M

W

F

D/E

M

W

F

D/E

M

W

F

D/E

M

D/EP D/E FP

F

8

7

8

9

10

11

W

I7 (sombreada) corresponde a la primera instrucción del siguiente bucle. PROBLEMA 17 Supongamos que en una máquina segmentada en cuatro etapas las paradas vienen provocadas por los riesgos entre una instrucción Ii, y las dos sucesoras, Ii!1 e Ii!2. Supongamos que las frecuencias de los riesgos que provocan paradas y el número de ciclos de parada son los indicados a continuación: Instr. Ii!1 (y no i ! 2) Instr. Ii!2

20%

2 ciclos

5%

1 ciclo

¿Cuál es el Speedup obtenido como consecuencia de la segmentación?


423

Solución: En este caso no nos hace falta conocer en qué etapas se divide el procesador puesto que se da toda la información que necesitamos para calcular el CPI: 4 % 2,10 CPI % 1 ! 0,2 # 2 ! 0,5 # 1 % 1,9 ; SPEEDUP % 1,9 PROBLEMA 18 Un computador tiene el ciclo de instrucción segmentado en 7 etapas: F1, F2: Búsqueda de la instrucción, D: Lectura de operandos y decodificación, E: Cálculo de la dirección efectiva, operación en la ALU y condición de saltos, M1, M2: Acceso a memoria, W: Escritura del resultado. La frecuencia de reloj es de 200 MHz. La máquina usa cortocircuito para resolver los riesgos de datos. a) ¿Cuánto vale el branch delay slot? b) Si el compilador aplica la técnica de la carga retardada, ¿cuánto vale el LOAD delay slot? Solución: a) Como la dirección de salto y el cálculo de la condición se realizan en la etapa de ejecución el branch delay slot es de tres instrucciones BIF I siguiente

F1 F2

D

E

BD BD BD

M1 M2 W F

b) La instrucción de LOAD propociona el dato en la segunda etapa de memoria, por lo tanto la instrucción que espera este dato tiene que esperar dos ciclos de reloj para poder utilizar el dato en ejecución LOAD I siguiente

F1 F2

D

E

M1 M2 W

F1 F2 DP DP

D

E

PROBLEMA 19 Si el procesador del problema anterior ejecuta el siguiente fragmento de programa ADD R1,R2,R3 SUB R4,R1,R5 ADD R6,R1,R7 SUB R8,R1,R9 ADD R10,R1,R11 SUB R12,R1,R13 ADD R14,R1,R15 Indica los cortocircuitos necesarios para resolver todos los riesgos de datos que se produzcan.

424


Solución: Se puede observar en el programa que todas las instrucciones tienen dependencias LDE con I1, pero no se produce ninguna parada porque estamos utilizando cortocircuitos para evitarlo.

1

ADD R1,R2,R3

2

SUB R4,R1,R5

3

ADD R6,R1,R7

4

SUB R8,R1,R9

5

ADD R10,R1,R11

6

SUB R12,R1,R13

7

ADD R14,R1,R15

1

2

3

4

5

6

7

8

9

10

11

12

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

W

F1

F2

D

E

M1

M2

13

W

El destino de todos los cortocircuitos es la etapa de ejecución pero el origen varía en función de la etapa en la que se encuentre la instrucción que tiene que proporcionar el dato. I2 toma el dato del registro E/M1. I3 toma el dato del registro M1/M2. I4 toma el dato del registro M2/W. I5 se aprovecha de que el banco de registros se puede escribir en el primer ciclo de reloj y leer en el segundo, por lo tanto ya no necesita cortocircuito. El resto de las instrucciones lo leen del banco de registros durante su etapa de decodificación. PROBLEMA 20 Sea un procesador segmentado en las siguientes nueve etapas: F1, F2: Búsqueda de instrucción. D: Lectura de operandos y decodificación, E1, E2, E2: Ejecución, cálculo de dirección efectiva y condición de salto, E3: escritura del PC, M1, M2: Acceso a memoria, WB: escritura en registro (1.er semiciclo). Sabiendo que el procesador también tiene implementada las técnica del cortocircuito. a) Si los riesgos de control se resuelven mediante paradas, ¿cuántas paradas hay que generar para evitar el riesgo? b) Si para la instrucción de LOAD aplica parada y cortocircuito en decodificación cuando existen instrucciones dependientes de ella, ¿qué casos y qué paradas habría que meter en cada caso? Solución: a)

BIF I siguiente

F1 F2

D

E1 E2 E3 M1 M2 W

BD BD BD BD BD F1 F2 E1 E2 E3 M1 M2 W

El procesador tiene que generar 5 paradas para evitar los riesgos de control.


425

b) Vamos a poner en un solo diagrama todos los casos en los que hay una instrucción que depende del resultado del LOAD LOAD

F1 F2

D

E1 E2 E3 M1 M2 W

Ii!1

F1 F2 DP DP DP DP

D

E1 E2 E3 M1 M2 W

Ii!2

F1 F2 DP DP DP

D

E1 E2 E3 M1 M2 W

Ii!3

F1 F2 DP DP

D

E1 E2 E3 M1 M2 W

Ii!4

F1 F2 DP

D

E1 E2 E3 M1 M2 W

Ii!5

F1 F2

D

E1 E2 E3 M1 M2 W

11.5 Problemas propuestos PROBLEMA 1 El siguiente fragmento de código se ejecuta en un procesador segmentado: LOOP: LD F2, 0(R1) LD F10,0(R5) MULTD F4, F2, F0 MULTD F8,F0,F10 LD F6, 0(R2) ADDD

F6, F4, F6

ADDD

F8, F4,F8

SD

0(R2), F6

SD

0(R6),F8

ADDI

R1, R1, 8

ADDI

R2, R2, 8

ADDI

R5,R5,8

ADDI

R6,R6,8

SGTI

R3, R1, DONE

BEQZ

R3, LOOP

NOP Sabiendo que: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. La detección de riesgos LDE y parada se realiza en la etapa de decodificación. La detección de riesgos estructurales y parada se realiza en la etapa de decodificación. Los saltos se resuelven en la etapa de decodificación.

426


Se emplea la técnica de compilación salto retardado de una instrucción para reducir las paradas por riesgo de control. Se permite que coexista una STORE y una instrucción aritmético-lógica en la misma etapa. Las unidades funcionales tienen las siguientes características: UF

Cantidad

Latencia

Segmentada

FP ADD

1

2

No

FP MUL

1

3

No

INT ALU

1

1

No

Determinar el CPI teniendo en cuenta que done%0 # 1000 y R1%0 # 0100 al inicio de la ejecución y se supone que no se dispone de lógica de cortocircuito. PROBLEMA 2 El siguiente fragmento de código se ejecuta en un procesador segmentado: LOOP: LD F2, 0(R1) LD F10,0(R5) MULTD F4, F2, F0 MULTD F8,F0,F10 LD F6, 0(R2) ADDD

F6, F4, F6

ADDD

F8, F4,F8

SD

0(R2), F6

SD

0(R6),F8

ADDI

R1, R1, 8

ADDI

R2, R2, 8

ADDI

R5,R5,8

ADDI

R6,R6,8

SGTI

R3, R1, DONE

BEQZ

R3, LOOP

NOP Suponiendo que: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. La detección de riesgos LDE y parada se realiza en la etapa de decodificación. La detección de riesgos estructurales y parada se realiza en la etapa de decodificación.


427

Los saltos se resuelven en la etapa de decodificación. Se emplea la técnica de compilación salto retardado de una instrucción para reducir las paradas por riesgo de control. Se permite que coexista una STORE y una instrucción aritmético-lógica en la misma etapa. Las unidades funcionales tienen las siguientes características: UF

Cantidad

FP ADD

Latencia

Segmentada

2

Sí

FP MUL

1

3

Sí

INT ALU

1

1

No

a) Determinar el CPI teniendo en cuenta que done % 0 # 1000 y r1 % 0 # 0100 al inicio de la ejecución y se supone que se dispone de lógica de cortocircuito. b) Determinar el CPI teniendo en cuenta que done % 0 # 1000 y r1 % 0 # 0100 al inicio de la ejecución y se supone que no se dispone de lógica de cortocircuito. PROBLEMA 3 Considerar los procesadores de los dos problemas anteriores. Se sabe que el procesador con las unidades sin segmentar trabaja a una frecuencia de 500 Mhz y el procesador con las unidades segmentadas trabaja a una frecuencia de 400 MhZ. Calcular: a) Tiempo de ejecución del segmento de programa en cada procesador. b) MIPS de cada procesador. c)

Speedup del procesador con unidades segmentadas frente a unidades sin segmentar.

PROBLEMA 4 El siguiente fragmento de código se ejecuta en un procesador segmentado: LOOP: LD F2, 0(R1) LD F10,0(R5) MULTD F4, F2, F0 MULTD F8,F0,F10 LD F6, 0(R2) ADDD F6, F4, F6 ADDD F8, F4,F8 SD 0(R2), F6 SD 0(R6),F8 ADDI R1, R1, 8 ADDI R2, R2, 8

428


ADDI R5,R5,8 ADDI R6,R6,8 SGTI R3, R1, DONE BEQZ R3, LOOP LOAD F4,67(R5) Suponiendo que: Un dato se puede escribir en un registro y leer su valor en el mismo ciclo. La detección de riesgos LDE y parada se realiza en la etapa de decodificación. La detección de riesgos estructurales y parada se realiza en la etapa de decodificación. Los saltos se resuelven en la etapa de ejecución. Se emplea la predicción estática HW salto no tomado sabiendo que la predicción acierta el 45% de las veces. No se permite que coexista una STORE y una instrucción aritmético-lógica en la misma etapa. Las unidades funcionales tienen las siguientes características: UF

Cantidad

Latencia

Segmentada

FP ADD

1

2

No

FP MUL

1

3

No

INT ALU

1

1

No

a) Determinar el CPI teniendo en cuenta que done % 0 # 1000 y r1 % 0 # 0100 al inicio de la ejecución y se supone que se dispone de lógica de cortocircuito. b) Determinar el CPI teniendo en cuenta que done % 0 # 1000 y r1 % 0 # 0100 al inicio de la ejecución y se supone que no se dispone de lógica de cortocircuito. PROBLEMA 5 Suponiendo las características de los procesadores del problema anterior: a) Sabiendo que la frecuencia es la misma para los dos procesadores, calcular el speedup del procesador con cortocircuito, frente al que no usa cortocircuito. b) Calcular el CPI para los dos casos suponiendo que soluciona los riesgos de control mediante predicción estática de HW siempre tomado, sabiendo que acierta el 88% de las veces. PROBLEMA 6 Supongamos que la versión básica de un procesador segmentado en cinco etapas para operaciones enteras se modifica de la siguiente forma: – Las etapas DEC y EX se funden en una sola. – Como consecuencia la duración del ciclo de reloj debe incrementarse en un 45%.


429

Hallar la relación de velocidades entre la versión original del procesador y la modificada. Supóngase que el 13% de las instrucciones son de carga seguidas de un uso inmediato del operando cargado, y que el 35% son saltos condicionales donde la política de tratamiento de saltos no permite realizar trabajo útil en el «delay slot». PROBLEMA 7 Consideremos la organización básica de un procesador segmentado en 5 etapas con una carga de trabajo tal que: En el 23% de los casos la instrucción i ! 1 presenta una dependencia LDE respecto de la i. En el 18% de estas situaciones la instrucción i es de LOAD. En el 11% de los casos la instrucción i ! 2, pero no la i ! 1, presenta una dependencia LDE respecto de la i. En el 9% de los casos la instrucción i es de LOAD. En el 2% de los casos la instrucción i ! 3, pero no la i ! 2, ni la i ! 1, presentan una dependencia LDE respecto de la i. El 25% de las instrucciones son de salto y el 40% de los saltos se toman. a) Determinar en promedio el número de ciclos de reloj que se precisan para ejecutar cada instrucción, en cada uno de los siguientes supuestos. b) Si además se añade el HW necesario para resolver los saltos en la etapa de decodificación y se asume la predicción de que los saltos no se toman. c)

Si con la estructura HW del apartado anterior, se implementa una política de saltos retardados, donde en el 60% de los casos el hueco de retardo (delay slot) se rellena con una instrucción. De éstas no se deberían haber ejecutado el 35%. En el resto de casos lo rellena con NOP.

PROBLEMA 8 Supongamos un procesador en el que los accesos a la memoria cache de datos y cache de instrucciones se han segmentado en tres etapas. Las lecturas de datos y de instrucciones se pueden realizar en la etapa 2 de memoria, mientras que la escritura se realiza en la etapa 3. La detección y paradas por riesgo LDE y EDE se realizan en decodificación. La resolución del salto se realiza en ejecución. El procesador utiliza la técnica de salto retardado para evitar, en la medida de lo posible, las paradas por riesgos de control. Sabiendo que la multiplicación en coma flotante se ejecuta en cuatro ciclos y la suma en coma flotante en dos, si el procesador ejecuta el siguiente programa: LOAD F2,0(R1) LOOP: MULD F4, F2, F0 ADDD F6, F4,F2 SUBI R1,R1,Ⲇ8 BNZ LOOP LOAD F2,0(R1) LOAD F4 Calcular el diagrama fase-ciclo para la ejecución del último bucle.

430


PROBLEMA 9 Supongamos que la versión básica de un procesador segmentado en cinco etapas para operaciones enteras en el que las etapas EX y MEM se funden en una sola. Como consecuencia la duración del ciclo de reloj debe incrementarse en un 35%. Hallar la relación de velocidades entre la versión original del procesador y la modificada. Supóngase que en el 14% de las instrucciones son de carga seguidas de un uso inmediato del operando cargado, y que el 17% de las instrucciones son saltos condicionales donde la política de tratamiento de saltos no permite realizar trabajo útil en el «delay slot». PROBLEMA 10 Consideremos la organización básica de un procesador segmentado en 5 etapas, en donde cada etapa opera en un ciclo de reloj. Supongamos que su carga de trabajo es tal que: En el 38% de los casos la instrucción i ! 1 presenta una dependencia LDE respecto de la i. En el 10% de estas situaciones la instrucción i es de LOAD. En el 13% de los casos la instrucción i ! 2, pero no la i ! 1, presenta una dependencia LDE respecto de la i. En el 50% de los casos la instrucción i es de LOAD. En el 5% de los casos la instrucción i ! 3, pero no la i ! 2, ni la i ! 1, presentan una dependencia LDE respecto de la i. El 25% de las instrucciones son de salto y el 40% de los saltos se toman. Determinar en promedio el número de ciclos de reloj que se precisan para ejecutar cada instrucción, en los siguientes supuestos: a) Con la organización básica del procesador (sin anticipación de operandos, ni aceleración de saltos y bloque de registros disponible en ciclo siguiente a la escritura). b) Si se modifica la estructura básica para implementar la anticipación de operandos (cortocircuito). c)

El procesador tiene el HW necesario para resolver los saltos en la etapa de decodificación y se asume la predicción de que los saltos no se toman (predict-not-taken).

d) Si con la estructura HW del apartado anterior, se implementa una política de saltos retardados, donde en el 63% de los casos el hueco de retardo (delay slot) se rellena con una instrucción previa al salto, en el 28% con una instrucción del destino del salto y en el resto con NOP.

El sistema de memoria es el lugar donde residen los programas y datos ya que según la arquitectura Von Neumann un programa debe estar almacenado en memoria para poder ser ejecutado. El sistema de memoria se organiza de manera jerárquica de forma que se tenga un sistema de alta capacidad y velocidad próxima a la de los dispositivos más rápidos y un coste cercano al de los dispositivos más lentos y baratos, tal y como muestra la figura siguiente:

Jerarquía de memoria. Relación coste, capacidad y tiempo de acceso.

El hecho de encontrar (acierto) o no encontrar (fallo) un elemento en un determinado nivel de la jerarquía determinará la bondad y el rendimiento del sistema completo. Para aumentar el rendimiento de la memoria principal se debe aumentar el ancho de banda de la misma. Los mecanismos generales para aumentar el ancho de banda de memoria se muestran en la siguiente figura:

432


Aumento del rendimiento de memoria.

Estos mecanismos son: (a) reducción de su tiempo de acceso, (b) aumento del tamaño de palabra y (c) permitir el acceso concurrente a varios módulos de memoria mediante una organización entrelazada.

12.1 Propiedades de la jerarquía de memoria Inclusión: Cualquier información almacenada en el nivel de memoria Mi, debe encontrarse también en los niveles Mi!1, Mi!2, ..., Mn. Coherencia: Las copias de la misma información existentes en los distintos niveles deben ser consistentes, es decir, si un bloque de información se modifica en el nivel Mi, deben actualizarse los niveles Mi!1, ..., Mn. Esto se consigue mediante dos métodos: Escritura directa (write-through): Cuando una palabra se modifica en el nivel Mi, inmediatamente se actualiza en el nivel Mi!1. Post-escritura (write-back): La actualización del nivel Mi!1 se retrasa hasta que el bloque que se modificó es reemplazado o eliminado en el nivel Mi. Localidad: La propiedad de localidad dice que las referencias a memoria generadas por la CPU, para acceso a datos o a instrucciones, están concentradas o agrupadas en ciertas regiones del tiempo y del espacio. Localidad temporal: Si se referencia un elemento, éste tenderá a ser referenciado en un corto intervalo de tiempo. Localidad espacial: Si se referencia un elemento, los elementos cercanos a él tenderán a ser referenciados también. Se denomina bloque a la unidad mínima de transferencia entre los dos niveles.

Capítulo 12 Memoria

433

Se produce un acierto (hit) si el dato solicitado está en el nivel i. Se conoce como tasa de aciertos (hit ratio) a la fracción de accesos encontrados en el nivel i. El tiempo de acierto es el tiempo de acceso del nivel i ! el tiempo de detección de acierto. De la misma forma se produce un fallo (miss) cuando el dato solicitado no está en el nivel i y es necesario buscarlo en el nivel i ! 1. La tasa de fallos (miss ratio) es 1 . tasa de aciertos. El tiempo de penalización por fallo es el tiempo de sustitución de un bloque del nivel i ! tiempo de acceso al dato. Se cumple que, en un sistema de memoria formado por dos niveles, Memoria Cache (MC) y Memoria Principal (MP), el tiempo medio de acceso viene dado por la siguiente expresión: tacc % h # tc ! (1 . h) # (tc ! tp) Donde h es la tasa de aciertos en la MC, tc es el tiempo de acceso a MC y tp es el tiempo de acceso a MP. En una jerarquía con varios niveles, el tiempo de acceso viene dado por la siguiente fórmula: n

tacc % ; (1 . h(Li.1)) # ti i%1

Donde h(Li.1) es la razón de aciertos en el nivel i . 1 y ti es el tiempo de acceso en el nivel i. Cuando se produce un fallo, no sólo se transfiere la palabra necesaria, sino que se transfiere todo un bloque. Esto se realiza en favor de los principios de localidad espacial y temporal.

12.2 La memoria cache La memoria cache es una memoria pequeña y rápida situada entre el procesador y la memoria principal. Almacena una copia de la porción de información actualmente en uso de la memoria. Su objetivo es disminuir el tiempo de acceso al sistema global de memoria. La figura siguiente muestra la estructura del sistema MC/MP, así como el formato de la Dirección Física (DF):

Estructura del sistema MC-MP.

434


Así, la MP está formada por 2n palabras direccionables, dividida en nB bloques de tamaño fijo de 2k palabras por bloque. La MC, en cambio, está formada por nM marcos de bloque de 2k palabras cada uno (nM @ nB). El directorio de memoria cache indica qué subconjunto de los nB bloques residen en los nM marcos de bloque. En el diseño de la MC se debe tener en cuenta la optimización de los siguientes parámetros: probabilidad de acierto, tiempo de acceso efectivo, retardos debidos a fallos y mantenimiento de la correspondencia entre bloques de MP y MC. Para ello se deben definir adecuadamente y tener en cuenta las políticas y parámetros siguientes: Política de emplazamiento: determina la correspondencia entre bloques de MP y MC. Dichas políticas son: Emplazamiento directo: Cada bloque B tiene asignado un único marco M en donde ubicarse. Este marco viene dado por la expresión: M % B mod nM. Si nM % 2m entonces M % (m bits menos significativos de B). En este caso el directorio almacena para cada marco una etiqueta con los n-k-m bits que completan la dirección del bloque almacenado. El acceso al marco y al directorio es directo. Para conocer si un bloque está cargado en MC, basta con comparar las etiquetas. Emplazamiento asociativo: Cada bloque B puede ubicarse en cualquier marco M (también se denomina vía). El directorio guarda para cada marco una etiqueta con los n-k bits que identifican al bloque almacenado. El acceso al marco y al directorio es asociativo. Para conocer si un bloque está cargado, la MC compara la etiqueta dada con todas las etiquetas del directorio. Emplazamiento asociativo por conjuntos: La MC está dividida en nC conjuntos de nM/nC marcos cada uno. Cada bloque B tiene asignado un conjunto fijo C y puede ubicarse en cualquiera de los marcos que componen dicho conjunto. Este conjunto viene dado por la expresión: C % B mod nC. Si nC % 2m entonces C % (m bits menos significativos de B). El directorio almacena para cada marco una etiqueta con los n-k-m bits que completan la dirección del bloque almacenado. El acceso al conjunto es directo y al marco dentro del conjunto asociativo.

Formatos de dirección física con respecto a las distintas políticas de emplazamiento en memoria cache.

Política de sustitución: Determina qué bloque abandona MC para dejar espacio a otro de MP cuando no existe espacio libre para este bloque en MC. Así, se define espacio de reemplaza-


435

miento al conjunto de posibles bloques que pueden ser sustituidos por el nuevo bloque. Las políticas más usadas son: Directa: El bloque que reside en marco que el nuevo bloque tiene asignado. Al no existir alternativas no se requieren algoritmos de sustitución. Asociativa: Se sustituye cualquier bloque que resida en la MC. Asociativa por conjuntos: Se sustituye cualquier bloque que resida en el conjunto que el nuevo bloque tiene asignado. Mediante algoritmo: Los algoritmos más usados son (1) aleatorio, donde se escoge un bloque del espacio de reemplazamiento al azar, (2) FIFO, en que se sustituye el bloque del espacio de reemplazamiento que lleve más tiempo cargado, (3) LRU (least recently used), donde se sustituye el bloque del espacio de reemplazamiento que lleve más tiempo sin haber sido referenciado, y (4) LFU (least frequently used), en que se sustituye el bloque que haya sido referenciado en menos ocasiones. Política de actualización: Es necesaria para mantener la coherencia entre la MC y la MP. Determina cuándo se actualiza un bloque de la MP si éste ha sido previamente modificado en la MC. Existen dos alternativas: Escritura inmediata (write-through): Cada vez que se hace una escritura en la MC se actualiza inmediatamente la MP. Existen dos variantes en función de lo que sucede en caso de fallo de escritura: (a) con asignación en escritura, es decir, un bloque se carga en MC como consecuencia de fallos de lectura y escritura, y (b) sin asignación en escritura, donde un bloque se carga en MC solamente como consecuencia de fallos de lectura, lo fallos de escritura no cargan bloque y acceden directamente a MP. Post-escritura (write-back): La MP se actualiza sólo cuando se reemplaza el bloque. En MC se cargan bloques tanto por fallos de lectura como de escritura. Por lo tanto, se utiliza un bit de actualización por bloque que indica si debe actualizarse en MP, de forma que cuando se realiza una escritura se activa y cuando se realiza una sustitución se comprueba si está activado o no. Política de búsqueda: Determina qué bloques (y en qué momento) deben cargarse en MC. Búsqueda por demanda: Un bloque se trae a MC cuando se necesita, es decir, como consecuencia de un fallo. Búsqueda anticipativa: Un bloque se trae a MC antes de que se necesite para reducir la tasa de fallos. Lo más común es elegir el bloque siguiente al referenciado (one block lookahead). Existen dos variantes, a saber, (1) pre-búsqueda por fallo, donde si se produce un fallo al acceder a un bloque se buscan dicho bloque y el siguiente, y (2) prebúsqueda siempre, en la que la primera vez que se referencia un bloque se pre-busca el siguiente. Organización de la cache: En cuanto al tamaño de la MC y sus bloques, aumentar el tamaño del bloque hace que aumente la tasa de aciertos, por la localidad espacial y que disminuya el número de bloques en MC por la localidad temporal. Mientras, disminuir el tamaño del bloque hace que disminuya la cantidad de tráfico de información entre MC y MP. Respecto a la unicidad y homogeneidad de la MC, las instrucciones presentan localidad temporal y los datos espacial; tener dos caches separadas una para datos y otra para instrucciones permite el acceso simultáneo a instrucciones y datos (aumenta la velocidad) y definir las políticas más adecuadas para cada una de ellas. Finalmente, en cuanto a caches de uno o dos niveles, existe una

436


mejora de las prestaciones con una MC de dos niveles. Normalmente el primer nivel de MC se encuentra integrado en el procesador lo que elimina el acceso al bus y disminuyen los tiempos de ejecución.

12.3 Memoria virtual El objetivo es dar la impresión de que el computador dispone de una memoria ilimitada. Para ello combina dos dispositivos de almacenamiento de diferente capacidad, velocidad y coste. La Memoria Virtual (MV) separa los conceptos de direcciones lógicas o virtuales (capacidad de direccionamiento) y direcciones físicas (la memoria instalada). La siguiente figura muestra un esquema de traducción de MV a MP. El procesador trabaja con la memoria principal, pero sus direcciones pertenecen a la memoria virtual.

Traducción de direcciones virtuales.

Por lo tanto, la traducción es necesaria debido a que los programas generan direcciones lógicas (virtuales) pero para la ejecución se necesitan direcciones físicas. Traducción de direcciones: Existen tres alternativas. Memoria virtual paginada El espacio virtual de direcciones se divide en páginas de tamaño fijo. El espacio físico de direcciones se divide en marcos de página del mismo tamaño que una página. El esquema de traducción de direcciones se muestra en la figura de la página siguiente. En este caso existen varios mecanismos de traducción: Traducción directa: Existe una Tabla de Páginas (TP) por cada proceso con una entrada por cada página que nos dice si la página está en MP y en qué marco está ubicada. Cada proceso tiene un registro base que señala a su TP. Traducción asociativa: El objetivo es reducir el tamaño de la TP. Sólo es necesario mantener una entrada en la TP para aquellas páginas que están en MP, es decir, la TP tiene una entrada por cada marco de página en MP.


437

Memoria virtual paginada. Traducción de direcciones.

Traducción mixta: Se pretende reducir el tamaño de la tabla asociativa para reducir su coste. Para ello se mantiene una pequeña tabla asociativa con las páginas más activas, llamada TLB (Translation Lookaside Buffer). Por otro lado se debe guardar la TP completa para traducir una dirección cuya entrada no se encuentre en la TLB. Traducción a varios niveles: El objetivo en este caso es resolver el problema del almacenamiento de la TP. Para ello se divide la TP en varias páginas. Algunas páginas de la TP pueden residir en MP (no necesariamente contiguas), mientras que el resto de páginas pueden residir en Memoria Secundaria (MS). Con esto se utiliza una tabla de directorios que almacena las direcciones de comienzo de las páginas de la TP. Esta tabla se almacena en MP. Por lo tanto, la dirección virtual se divide en tres campos: DV % (N.o de Directorio, N.o de Página, Desplazamiento). Este mecanismo se puede combinar con el uso de una TLB con las páginas más activas. Memoria virtual segmentada El espacio virtual de direcciones se divide en segmentos de tamaño variable. La siguiente figura muestra un esquema del mecanismo de traducciones

Memoria virtual segmentada. Traducción de direcciones.

438


El mecanismo de traducción es el de traducción directa, donde cada proceso almacena una Tabla de Segmentos (TS) que contiene una entrada por cada posible segmento del proceso. La entrada S-ésima de la TS contiene la dirección inicial de MP donde comienza el segmento S (si está en MP). Cada proceso guarda en un registro la dirección inicial de la TS. Memoria virtual segmentada/paginada El espacio virtual de direcciones se divide en segmentos de tamaño variable. Cada segmento está compuesto por un número variable de páginas de igual tamaño. El espacio físico de direcciones se divide en marcos de página del mismo tamaño que una página.

Memoria virtual segmentada/paginada. Traducción de direcciones.

Los mecanismos de traducción son: Traducción directa: Cada entrada de la TS almacena la dirección de comienzo de la tabla de páginas (TP) de ese segmento. La TP del segmento S contiene una entrada por cada página P de ese segmento. Cada proceso mantiene una tabla de segmentos (TS). Traducción mixta: Se mantiene una pequeña tabla asociativa (TLB) con las páginas más activas. Por otro lado debemos guardar la TS (en MP) y las TPs de los distintos segmentos (en MP o MS) para traducir las direcciones cuya entrada no se encuentre en la TLB.

12.4 Problemas resueltos PROBLEMA 1 Determinar el tiempo medio de acceso a un sistema de memoria formado por una memoria cache (MC), con un tiempo de acceso de 10 ns, y una memoria principal (MP) con un tiempo de acceso de 60 ns. La probabilidad de acierto de la memoria cache es del 70%.


439

Solución: En un sistema de memoria formado por dos niveles (MC y MP), el tiempo medio de acceso viene dado por la expresión: tacc % h # tc ! (1 . h) # (tc ! tp) Donde h es la tasa de aciertos en la MC, tc es el tiempo de acceso a MC y tp es el tiempo de acceso a MP. En nuestro caso, h % 0,7, tc % 10 ns y tp%60 ns, por lo tanto: tacc % 0,7 # 10 ! (1 . 0,7) # (10 ! 60) % 28 ns PROBLEMA 2 Un sistema jerárquico de memoria está formado por los siguientes niveles: tacc

Tamaño

h

Coste

Memoria cache (MC)

5 ns

512 KB

50 e/MB

0,95

Memoria principal (MP)

50 ns

128 MB

0,4 e/MB

0,99999995

Disco magnético

10 ms

20 GB

0,01 e/MB 1,00

a) Calcular el tiempo medio de acceso para dicho sistema. b) Calcular el coste medio, en e/MB, del mismo. c)

Comentar los resultados obtenidos.

Solución: a) En una jerarquía con varios niveles, el tiempo de acceso viene dado por la siguiente fórmula: n

tacc % ; (1 . h(Li.1)) # ti i%1

Donde h(Li.1) es la razón de aciertos en el nivel i . 1 y ti es el tiempo de acceso en el nivel i. En este caso tenemos tres niveles, con sus respectivos tiempos de acceso y razón de aciertos. Teniendo en cuenta que h(L0) % 0, ya que el nivel cero no existe, podemos sustituir los datos en la ecuación anterior, obteniendo: tacc % 1 # 5 # 10.9 ! 0,05 # 50 # 10.9 ! 0,00000005 # 10 # 10.8 % 8 ns b) El coste medio vendrá dado por el coste total de la memoria (en euros) dividido por el tamaño total de ésta (en MB): Coste total Coste medio % Tamaño

440


Coste medio% c)

0,5#50!128#0,4!20#1.024#0,01 281 e % %0,0136 e/MB 0,5!128!20#1.024 20.608,5 MB

Empleando una jerarquía de memoria obtenemos un sistema con una capacidad total del orden del tamaño del disco magnético, con un tiempo medio de acceso próximo al de la memoria más rápida (memoria cache) y con un coste medio por MB próximo al de la memoria más barata (disco magnético).

PROBLEMA 3 Sea una memoria principal de 1 Mpalabras de tamaño con unos tiempos de acceso de 100 ns y dividida en bloques de 2 palabras. Sabiendo que el sistema tiene una memoria cache asociativa por conjuntos de 28 palabras, un grado de asociatividad de 4 y un tiempo de acceso de 10 ns, calcular: a) Número de bits de la dirección física. b) Número de conjuntos de la memoria cache. c)

Formato de las direcciones de memoria cache.

d) Mejora del rendimiento del sistema si la tasa de fallos es del 25%. Solución: a) Si la memoria tiene un tamaño de 1 Mpalabras necesitaremos acceder a 220 posiciones y por tanto el ancho de direcciones físicas es de 20 bits. b) Como el grado de asociatividad es 4, disponemos de 4 bloques por conjunto. Dado que la MC disponde de 28 marcos de bloque, el número de conjuntos será: nC %

c)

28 palabras % 25 conjuntos % 32 conjuntos marcos palabras 2 2 #2 conjunto marco

Para acceder a 32 conjuntos necesitamos 5 bits, para diferenciar entre 2 palabras/bloque un único bit, por lo tanto la etiqueta será de 20 . 5 . 1 % 14 bits y el formato quedará:

d) El rendimiento sin memoria cache será de 100 ns para cada acceso. Si incorporamos la memoria cache será: tacc % 0,75 # 10 ns ! (1 . 0,75) # (10 ns ! 100 ns) % 35 ns Que representa un 35% del tiempo original.


441

PROBLEMA 4 La memoria cache de una máquina tiene un tiempo de acceso de 5 ns, siendo el tiempo de acceso de la memoria principal de 50 ns. Se supone que el 30% de las peticiones de acceso son para escritura y el resto para lectura. Si la razón de aciertos de la memoria cache es de 0,80 y se emplea una política de actualización inmediata (write-through), calcular: a) El tiempo medio de acceso teniendo en cuenta sólo los ciclos de lectura. b) El tiempo medio de acceso si se tienen en cuenta también los ciclos de escritura. Solución: a) Sabemos que el tiempo medio de acceso (en este caso lectura) viene dado por: tlec % h # tc(1 . h) # (tc ! tp) Donde h es la tasa de aciertos en la MC, tc es el tiempo de acceso a MC y tp es el tiempo de acceso a MP. Por lo tanto, según los datos del enunciado, tenemos tlec % 0,8 # 5 ! (1 . 0,8) # (5 ! 50) % 15 ns b) Es fácil deducir que el tiempo medio de lectura/escritura será: tlec/esc % Prob. lectura # tlec ! Prob. escritura # tesc De los datos del enunciado tenemos: Probabilidad de acceso de lectura: 0,70. Probabilidad de acceso de escritura: 0,30. tlec % 15 ns, del apartado a). tesc % 50 ns, dado que se escribe a la vez en memoria principal y en memoria cache (política de escritura inmediata). Por lo tanto: tlec/esc % 0,70 # 15 ! 0,30 # 50 % 25,50 ns PROBLEMA 5 Los parámetros que definen la memoria de un computador son los siguientes: Memoria principal (MP): 8 Kbloques. Memoria cache (MC): 512 bloques. Bloque: 8 bytes. Determinar el formato de las direcciones físicas en los siguientes supuestos: a) Emplazamiento directo. b) Emplazamiento asociativo. c)

Emplazamiento asociativo por conjuntos, con 16 bloques por conjunto.

442


Solución: En primer lugar, calculamos los parámetros del sistema de memoria, suponemos que la unidad direccionable es el byte. Memoria principal: Dirección: 8 Kbloques # 8 bytes/bloque % 64 KB % 26 # 210 bytes % 216 bytes. Número de bloques en la MP: nB % 8 Kbloques % 213 bloques. Tamaño de bloque: 8 bytes % 23 bytes. Con lo que el formato de direcciones es:

Memoria cache: Tamaño: 521 bloques # 8 bytes/bloque % 4 KB % 212 bytes. Número de marcos de bloque en la MC: nM % 512 marcos de bloque % 29 marcos de bloque. Con estos parámetros podemos resolver los distintos apartados del problema. a) Un bloque B de la memoria principal se carga siempre sobre el marco de bloque M % B mod nM de la memoria cache. Una dirección de n % 16 bits de la MP se interpreta de la siguiente manera: Campo palabra (P): como un marco de bloque contiene 23 bytes, este campo es de 3 bits. Campo marco de bloque (M): al disponer de 29 marcos en MC, este campo es de 9 bits. Etiqueta: Será el número de bits restante de la dirección de MP, esto es 16.3.9%4 bits.

b) Un bloque B de MP puede cargarse en cualquier marco de bloque M de MC. Los 16 bits de dirección se reparten en 3 bits para el byte dentro del bloque y el resto (13 bits) se reservan para la etiqueta, por lo tanto el formato queda:

c)

En este caso se dispone en MC de 16 bloques por conjunto. Como la memoria cache dispone de un total de 512 bloques, el número de conjuntos en MC es: nC %

512 bloques % 32 conjuntos % 25 conjuntos bloques 16 conjunto


443

Se reservan entonces 3 bits para la palabra, 5 bits para el conjunto y el resto (16 . 5 . 3 % 8) para la etiqueta.

PROBLEMA 6 Un computador posee una memoria principal (MP) de 256 MB y una memoria cache (MC) de 128 KB. Los datos se transfieren entre MP y MC en bloques de 8 B. Determinar el tamaño de los diferentes campos que conforman una dirección física en cada uno de los siguientes supuestos: a) Emplazamiento directo. b) Emplazamiento asociativo. c)

Emplazamiento asociativo por conjuntos de dos vías.

Solución: En primer lugar, calculamos los parámetros del sistema de memoria, suponemos que la unidad direccionable es el byte. Memoria principal: Dirección: 256 MB % 28 # 220 bytes % 228 bytes. Tenemos por tanto 28 bits de dirección. Tamaño de bloque: 8 bytes % 23 bytes. Número de bloques en la MP: nB % 256 MB / 8 B/bloque % 32 Mbloques % 225 bloques. Con lo que el formato de direcciones es:

Memoria cache: Tamaño: 128 KB % 217 bytes. Número de marcos de bloque en la MC: nM % 128 KB / 8 B/bloque % 16 Kbloques % % 214 bloques. Con estos parámetros podemos resolver los distintos apartados del problema. a) Un bloque B de la memoria principal se carga siempre sobre el marco de bloque M % B mod nM de la memoria cache. Una dirección de n % 28 bits de la MP se interpreta de la siguiente manera: Campo palabra (P): como un marco de bloque contiene 23 bytes, este campo es de 3 bits. Campo marco de bloque (M): al disponer de 214 marcos en MC, este campo es de 14 bits. Etiqueta: Será el número de bits restante de la dirección de MP, esto es 28.14.3%11 bits.

444


b) Un bloque B de MP puede cargarse en cualquier marco de bloque M de MC. Los 28 bits de dirección se reparten en 3 bits para el byte dentro del bloque y el resto (25 bits) se reservan para la etiqueta, por lo tanto el formato queda:

c) En este caso se dispone en MC de 2 bloques por conjunto (2 vías). Como la memoria cache dispone de un total de 214 bloques, el número de conjuntos en MC es: 214 bloques % 213 conjuntos nC % bloques 2 conjunto Se reservan entonces 3 bits para la palabra, 13 bits para el conjunto y el resto (28 . 13 . 3 % 12) para la etiqueta.

PROBLEMA 7 Una memoria cache con emplazamiento asociativo por conjuntos dispone de un total de 64 bloques divididos en conjuntos de 4 bloques cada uno. La memoria principal dispone de 1.024 bloques con 16 palabras por bloque. ¿Cuántos bits se necesitan para los campos etiqueta, conjunto y palabra de la dirección de memoria principal? Solución: Memoria principal: Tamaño: 1.024 bloques # 16 palabras/bloque % 16 Kpalabras % 214 palabras r 14 bits. Tamaño de bloque: 16 palabras % 24 r 4 bits. Número de bloques: nB % 1.024 bloques % 210 bloques r 10 bits. Memoria cache: Número de conjuntos: nC % 64 bloques / 4 bloques/conjunto % 16 conjuntos % 24 conjuntos r 4 bits.


445

El formato de dirección es:

El campo conjunto será de 4 bits, mientras que el campo palabra será también de 4 bits. El campo etiqueta será por tanto de 14 . 4 . 4 % 6 bits, tal como muestra la siguiente figura:

PROBLEMA 8 Sea un computador con una MP de 1 MB y dotado con una MC de 16 marcos de bloque de 64 bytes cada uno. a) Determinar el formato de la dirección de memoria física desde el punto de vista de la política de ubicación en memoria cache, especificando el número de bits que ocupa cada uno de los campos que la componen para los siguientes casos: (1) emplazamiento directo, (2) asociativo y (3) asociativo por conjuntos con 4 bloques por conjunto. b) Si se utiliza una política de sustitución LRU (implementada por registros de edad), calcular el número total de bits necesarios para implementar la MC en cada uno de los casos anteriores (incluyendo datos, etiquetas y registros de edad). Solución: a.1) Emplazamiento directo En el caso de emplazamiento directo puro, cada bloque de memoria principal puede ubicarse únicamente en un marco de bloque de cache concreto, dado por la expresión B mod nM. Por tanto el campo de marco de bloque en cache está formado por los bits que hacen falta para representar todos los bloques de cache. En este caso se indica que hay 16 marcos de bloque, por lo que se requieren 4 bits para representarlos en cache. El resto de bits de la dirección de memoria, tras descontar los que son utilizados para indicar el desplazamiento dentro de un bloque para acceder a una palabra (6 bits), son utilizados para la etiqueta. En el caso que nos ocupa son 20 . 4 . 6 % 10 bits, y la representación global de memoria principal para la cache que queda entonces es:

a.2) Emplazamiento asociativo En el caso de emplazamiento asociativo puro, cualquier bloque de memoria principal puede ubicarse en cualquier marco de bloque de cache, por tanto la etiqueta de marco

446


de bloque en cache está formada por todo el conjunto de bits que no sean utilizados para indicar el desplazamiento dentro de un bloque para acceder a una palabra. De este modo, ya que los bloques son de 64 bytes, se requieren 6 bits para acceder a la palabra y el resto de bits de la dirección de memoria principal (20 . 6 % 14 bits) se utilizan para la etiqueta. La representación de memoria principal para la cache queda:

a.3) Emplazamiento asociativo por conjuntos con 4 bloques por conjunto En este caso, hay 4 posibles conjuntos, ya que hay 16 marcos y en cada conjunto hay 4 bloques. Por lo tanto el campo que representa a los conjuntos requiere 2 bits y la representación de memoria principal para la cache queda:

b.1) Emplazamiento directo En el caso del emplazamiento directo no tiene sentido implementar ningún tipo de algoritmo de sustitución, ya que la ubicación de un cierto bloque queda fijada según la fórmula: M % B mod nM de este modo, no se utilizan registros de edad ni se puede implementar una política LRU. El número total de bits que se utilizan para implementar la MC es: Por marco: 10 bits para la etiqueta y 64 B para los datos. Al haber 16 marcos, el total es: 16 # 10 bits ! 16 # 64 B % 20 B ! 1.024 B % % 1.044 B % 8.352 bits. b.2) Emplazamiento asociativo En el caso del emplazamiento asociativo, cualquier bloque nuevo puede reemplazar cualquier bloque de la cache, por tanto necesitamos implementar un registro de edad que nos permita identificar el más antiguo entre los 16 marcos de bloques de la cache, es decir, necesitamos 4 bits para su implementación. Por tanto, el número total de bits que se utilizan para implementar la MC es: Por marco: 14 bits para la etiqueta, 4 bits para el registro de edad y 64 B para los datos. Al haber 16 marcos, el total es: 16#(14!4) bits!16#64 B%36 B!1.024 B% % 1.060 B % 8.480 bits.


447

b.3) Emplazamiento asociativo por conjuntos con 4 bloques por conjunto En el caso del emplazamiento asociativo por conjunto, cada bloque nuevo puede reemplazar uno de los 4 bloques de su conjunto asignado según la fórmula: M % B mod nM/nC de este modo, necesitamos implementar un registro de edad de 2 bits, que nos permita identificar el más antiguo entre los 4 marcos del conjunto asignado a cada bloque de MP. Por tanto, el número total de bits que se utilizan para implementar la MC es: Por marco: 12 bits para la etiqueta, 2 bits para el registro de edad y 64 B para los datos. Al haber 16 marcos, el total es: 16#(12!2) bits!16#64 B%8 B!1.024 B% % 1.052 B % 8.416 bits. PROBLEMA 9 Diseñar un sistema paginado de memoria virtual de acuerdo con las siguientes especificaciones: Tamaño del espacio virtual direccionable: 64 K. Tamaño del espacio de direcciones físicas: 8 K. Tamaño de la página: 512 palabras. Traducción directa. Solución: Número de páginas en memoria virtual: 64 # 1.024 % 128 512 Número de marcos de página en memoria física: 8 # 1.024 % 16 512 64 K % 216 direcciones virtuales implican 16 bits para la dirección virtual. 8 K % 213 direcciones físicas implican 13 bits para la dirección física. Como existen 128 páginas, la tabla de páginas contendrá 128 % 27 registros. Por lo tanto, los 7 bits más significativos de la dirección virtual se emplearán para seleccionar el registro correspondiente. Los 16 . 7 % 9 bits restantes conforman el desplazamiento dentro de la página. La siguiente figura ilustra un diseño básico del mecanismo de traducción de direcciones:

448


Traducción de direcciones.

PROBLEMA 10 Un sistema de memoria virtual segmentada emplea un formato para las direcciones virtuales de 12 bits: los tres de más peso se corresponden con el segmento y los nueve restantes al desplazamiento. Considere la siguiente información ubicada en la Tabla de Segmentos: N.o de segmento

Dirección base

Longitud

0

0D116

25816

1

8FC16

00E16

2

05A16

06416

3

52F16

24416

Se pide calcular las direcciones físicas correspondientes a las siguientes direcciones lógicas: a) 1FE16 b) 21A16 c)

20B16

d) 59016 e)

79016

Solución: a) 1FE16 % 000 1111111102 En primer lugar obtenemos el número de segmento, que se corresponde con los tres bits más significativos de la dirección virtual: Número de segmento r 0002 % Segmento 0 Podemos calcular el desplazamiento con los bits restantes de la dirección: Desplazamiento r 1111111102 % 1FE16 a 25816 (permiso de acceso)


449

Se obtiene permiso de acceso con el desplazamiento dado, ya que éste es menor que la longitud del segmento en este caso. La dirección física asociada será entonces: Dirección física r 0D116 (dir. base) ! 1FE16 (desplazamiento) % 2CF16 Procedemos de igual forma con el resto de los apartados. b) 21A16 % 001 0000110102 Número de segmento r 0012 % Segmento 1 Desplazamiento r 0000110102 % 01A16 b 00E16 (permiso denegado) Como el desplazamiento es mayor que la longitud del segmento se produce una excepción en la traducción de direcciones. c)

20B16 % 001 0000010112 Número de segmento r 0012 % Segmento 1 Desplazamiento r 0000010112 % 00B16 a 00E16 (permiso de acceso) Dirección física r 8FC16 (dir. base) ! 00B16 (desplazamiento) % 90716

d) 59016 % 010 1100100002 Número de segmento r 0102 % Segmento 2 Desplazamiento r 1100100002 % 19016 b 06416 (permiso denegado) Como el desplazamiento es mayor que la longitud del segmento se produce una excepción en la traducción de direcciones. e)

79016 % 011 1100100002 Número de segmento r 0112 % Segmento 3 Desplazamiento r 1100100002 % 19016 a 24416 (permiso de acceso) Dirección física r 52F16 (dir. base) ! 19016 (desplazamiento) % 6BF16

PROBLEMA 11 Un sistema de memoria virtual segmentada/paginada tiene una longitud para las direcciones virtuales de 32 bits dividida en los siguientes campos: La longitud del campo de número de segmento es de 12 bits, la del número de página es de 8 bits y la longitud del campo desplazamiento es de 12 bits. Se pide determinar el valor de la dirección física bajo los siguientes supuestos: El registro de inicio de la tabla de segmentos contiene el valor 1000016. La dirección virtual a decodificar es la 01B2A10F16. El contenido de la dirección 1001B16 en la tabla de segmentos es: 100F216. El contenido de algunos registros de la tabla de páginas es: – 1011B16 r 1516 – 1011C16 r FA16 – 1011D16 r AF16

450


Solución: La dirección virtual definida en el enunciado sigue el siguiente esquema:

El registro base de la tabla de segmentos contiene la dirección de memoria donde comienza la tabla de segmentos. Cada uno de los registros de esta tabla contiene la dirección base de la tabla de páginas correspondiente a un segmento. La dirección del registro de la tabla de segmentos la obtenemos al sumar la dirección base de la tabla de segmentos con el campo Segmento de la dirección virtual: 1000016 ! 01B16 % 1001B16 El contenido de la dirección 1001B16 en la tabla de segmentos es, según el enunciado, 100F216. Esta se corresponde con la dirección base de la tabla de páginas de este segmento. Sumándole el campo Página obtendremos la dirección del registro que contiene el número de marco de página: 100F216 ! 2A16 % 1011C16 Y, por lo tanto, el número de marco de página es: 10011C16 r FA16. Finalmente, la dirección física se obtiene concatenando el desplazamiento al número de marco de página. Dirección física: FA10F16. PROBLEMA 12 Un computador emplea memoria virtual segmentada/paginada y un mecanismo de traducción mixta mediante TLB. El tiempo de acceso a la memoria principal es de 50 ns y el tiempo empleado en una búsqueda en la TLB es de 5 ns. Considerando una razón de aciertos en la TLB del 85%, determinar el tiempo medio de acceso a la información almacenada en memoria. Solución: La TLB (Translation Lookaside Buffer) acelera de forma importante el acceso a la información. Suele almacenar la información relativa a las últimas direcciones de memoria a las que se ha accedido y proporciona directamente el número de marco de página para un conjunto reducido de pares segmento-número de página. Si suponemos que las páginas pedidas se encuentran en la memoria física, el tiempo de acceso suponiendo que se produce acierto en la TLB para extraer la página correspondiente es: t1 % tiempo de búsqueda en la TLB ! tiempo de acceso a memoria principal


451

de donde: t1 % 5 ns ! 50 ns % 55 ns Si dicha información no se encuentra en la TLB hay que acceder tres veces a la memoria principal: una a la tabla de segmentos para obtener la tabla de páginas asociada, otra a la tabla de páginas para obtener el número de marco de página, y finalmente una tercera vez para obtener la información. Por tanto t2 % tiempo de búsqueda en la TLB ! tiempo de tres accesos a memoria principal de donde: t2 % 5 ns ! 3 # 50 ns % 155 ns El tiempo medio de acceso será entonces: tacc % h # t1 ! (1 . h) # t2 % 0,85 # 55 ns ! 0,15 # 155 ns % 70 ns Si no existiese TLB, el tiempo medio de acceso para acceder a la información sería de 3 # 55 ns % 150 ns, ya que en este caso todos los accesos requerirían la consulta a la tabla de segmentos y a la tabla de páginas antes de acceder a la palabra buscada. PROBLEMA 13 Una memoria principal contiene tres marcos de página, que inicialmente están vacíos. Si se produce la siguiente secuencia de peticiones de página: 4, 2, 4, 5, 1, 4, 3, 1, 6, 5, 1. Determinar la razón de aciertos en los tres supuestos siguientes: a) Empleando una política de sustitución FIFO. b) Empleando una política de sustitución LRU. c)

Empleando la política de sustitución óptima.

Solución: a) Sustitución FIFO (First In, First Out) Es algoritmo procede de una forma muy sencilla. Cuando es necesario sustituir una página, este algoritmo selecciona la página que lleva más tiempo en la memoria, es decir, la que se ubicó primero. Páginas solicitadas

4

2

4

5

1

4

3

1

6

5

1

4

4

4

4

1

1

1

1

6

6

6

2

2

2

2

4

4

4

4

5

5

5

5

5

3

3

3

3

1

! Página más antigua

Número de aciertos: 2. Razón de aciertos: 2/11.

!

452


b) Sustitución LRU (Least Recently Used) En este caso se sustituye la página que no ha sido referenciada durante un intervalo de tiempo más largo, es decir, la menos recientemente usada. Páginas solicitadas

4

2

4

5

1

4

3

1

6

5

1

4

4

4

4

4

4

4

4

6

6

6

2

2

2

1

1

1

1

1

1

1

5

5

5

3

3

3

5

5

!

!

!

!

Página a sustituir

Número de aciertos: 4. Razón de aciertos: 4/11. c)

Sustitución óptima En este caso se sustituye la página que no vaya a utilizarse durante el periodo más largo de tiempo. Este algoritmo no puede implementarse, porque se basa en la petición futura de páginas, y por lo tanto no es posible su implementación. Sin embargo es un buen punto de referencia para hacer comparativas entre distintos algoritmos de sustitución. Páginas solicitadas

4

2

4

5

1

4

3

1

6

5

1

4

4

4

4

4

4

3

3

6

6

6

2

2

2

1

1

1

1

1

1

1

5

5

5

5

5

5

5

5

!

!

!

!

Página a sustituir

Número de aciertos: 5. Razón de aciertos: 5/11. Podemos por tanto concluir que en este caso el algoritmo LRU es el que ofrece mejores resultados. PROBLEMA 14 Supongamos un sistema con las siguientes características: memoria principal de 1 KB, memoria cache de 4 marcos de bloque de 4 palabras de 1 byte, inicialmente vacía con sustitución LRU (en los casos en que sea necesario). Se solicitan los accesos a las siguientes direcciones de una memoria de 1 KB: 1, 4, 8, 5, 20, 17, 19, 56, 9, 11, 4, 43. Se pide mostrar la evolución de la memoria cache para las siguientes políticas de emplazamiento:


453

a) Emplazamiento directo. b) Emplazamiento asociativo. c)

Emplazamiento asociativo por conjuntos de dos marcos/conjunto.

Solución: a) En este caso, como cada bloque dispone de cuatro palabras, B % DIR/4. Por otro lado, cada dirección tiene asociada un marco M % B mod nM % B mod 4. En consecuencia, los números de bloque y marco quedan como sigue: DIR:

1

4

8

5

B

0

1

2

1

5

4

M

0

1

2

1

1

0

20 17 19 56

9

11

4

43

4 14

2

2

1

10

0

2

2

1

2

2

Una vez obtenido esto vemos la evolución de la memoria cache, teniendo en cuenta que si llamamos a la dirección 0 llevaremos a la memoria cache todo su bloque B % 0, es decir de la palabra 0 a la 3. La siguiente tabla muestra la evolución de la memoria cache. En lugar de direcciones se indica directamente el bloque solicitado. Las celdas en fondo gris representan que se ha producido un fallo e indican dónde se produce la sustitución. M/B

0

1

2

1

5

4

4

14

2

2

1

10

0

0

0

0

0

0

4

4

4

4

4

4

4

1

1

1

5

5

5

5

5

5

1

1

2

2

2

2

2

14

2

2

2

10

1 2 3

b) En este caso no hace falta calcular M puesto que el marco será el primero que quede libre. Por el contrario hemos de llevar un registro de edad para saber qué marco sustituir en caso de que el conjunto correspondiente esté lleno. Representamos en la siguiente tabla la evolución de la memoria cache, donde el segundo número en cada celda representa el valor del registro de edad. M/B

0

1

2

1

5

4

4

14

2

2

0

080

081

082

082

083

480

480

481

482

482

483 1080

180

181

180

181

182

182

183

280

280

281

280

281

282

283

283 1480 1481 1481 1482 1483

580

581

581

1 2 3

582

583

583

1

180

10

282

181

454


c)

En este caso el conjunto asociado es C % B mod nC % B mod 2, y dentro de este conjunto se tomará el primer marco que quede libre. DIR:

1

4

8

5

B

0

1

2

1

5

4

M

0

1

0

1

1

0

20 17 19 56

9

11

4

43

4 14

2

2

1

10

0

0

0

1

0

0

Al igual que en el caso anterior, necesitamos un registro de edad, pero en esta ocasión restringido al conjunto al que se refiere cada bloque. C

M/B

0

1

2

1

5

4

4

14

2

2

1

10

0

0

080

080

081

081

081

480

480

481

280

280

280

281

280

280

280

281

281 1480 1481 1481 1481 1080

180

180

181

181

181

181

181

181

180

180

580

580

580

580

580

580

581

581

1 1

0

180

1

Resumimos la secuencia de aciertos y fallos en cache bajo las tres políticas de emplazamiento: DIR.

Directo

Asociativo

Asociativo por conjuntos

Tipo fallo

1

Fallo

Fallo

Fallo

Inicio

4

Fallo

Fallo

Fallo

Inicio

8

Fallo

Fallo

Fallo

Inicio

5

Acierto

Acierto

Acierto

XXX

20

Fallo

Fallo

Fallo

Conflicto

17

Fallo

Fallo

Fallo

Conflicto

19

Acierto

Acierto

Acierto

XXX

56

Fallo

Fallo

Fallo

Conflicto

9

Fallo

Fallo

Fallo

Conflicto

Acierto

Acierto

Acierto

XXX

4

Fallo

Fallo

Acierto

Conflicto

43

Fallo

Fallo

Fallo

Conflicto

11

455


Y finalmente, mostramos un mapa de la memoria cache al finalizar todas las referencias: Directo

Asociativo

Asociativo por conjuntos

Etiqueta

M

P

DIR

Etiqueta

P

DIR

Etiqueta

C

P

DIR

000001

00

00

16

00001010

00

40

0000010

0

00

8

00

01

17

01

41

0

01

9

00

10

18

10

42

0

10

10

00

11

19

11

43

0

11

11

01

00

4

00

8

0

00

40

01

01

5

01

9

0

01

41

01

10

6

10

10

0

10

42

01

11

7

11

11

0

11

43

10

00

40

00

56

1

00

4

10

01

41

01

57

1

01

5

10

10

42

10

58

1

10

6

10

11

43

11

59

1

11

7

11

00

00

4

1

00

20

11

01

01

5

1

01

21

11

10

10

6

1

10

22

11

11

11

7

1

11

23

000000

000010

00000010

00001110

00000001

0000101

0000000

0000010

PROBLEMA 15 Un computador tiene una memoria principal de 32 Kpalabras de 16 bits, y una memoria cache de 4 Kpalabras, dividida en 4 bloques/conjunto, con 64 palabras/bloque. Se supone que inicialmente la memoria cache está vacía. La CPU lee de forma consecutiva el contenido de las posiciones de memoria 0, 1, 2, ..., 4.351. A continuación, repite 9 veces más esta secuencia de lectura. La memoria cache es 10 veces más rápida que la memoria principal. Para la sustitución de bloques en la memoria cache se emplea la estrategia LRU. Estimar la mejora que se obtiene por la utilización de la memoria cache: MEJORA % 100 #

TMP . Tcache TMP

NOTA: Suponer que el tiempo empleado por el algoritmo LRU y el tiempo de escritura en cache se solapa con el tiempo de lectura de MP.

456


Solución: En primer lugar determinamos el formato de dirección de memoria principal: 32 Kpalabras necesitan 15 bits de direcciones (32K % 215). 32 Kpalabras, con bloques de 64 palabras/bloque, implican 512 bloques en memoria principal. Una memoria cache de 4 Kpalabras, dividida en 4 marcos/conjunto, con 64 palabras/ marco, hacen un total de 16 conjuntos (24 % 16) en memoria cache. Por tanto el campo conjunto tendrá 4 bits. Los bloques son de 64 palabras, por lo que el campo palabra tendrá 6 bits. Los 5 bits restantes, hasta completar los 15 bits de direcciones, constituyen el campo etiqueta. Resumiendo: Etiqueta: 5 bits. Conjunto: 4 bits. Palabra: 6 bits. Ahora se puede estudiar cómo la CPU lee 10 veces las direcciones 0 a 4.351, considerando dos casos: sin memoria cache y con ella. Se define: – Tiempo de acceso por palabra a la memoria cache % t. – Tiempo de acceso por palabra a la memoria principal % 10t. Sin memoria cache: Hay que leer 10 veces el contenido de las 4.352 direcciones de memoria. EI tiempo total de lectura en memoria principal (MP) es por tanto: TMP % 4.352 pal. # 10 #

10t % 435.200t pal.

Con memoria cache: El tiempo de lectura total es el tiempo de gestión de fallos (tiempo ocupado en traer los bloques desde MP a la memoria cache) más el tiempo de lectura de la memoria cache: T % Tfallos ! Tcache Como, tal como dice el enunciado, el tiempo empleado por el algoritmo LRU (si se utiliza) y el tiempo de escritura en la memoria cache se solapa con el tiempo de lectura en MP, el tiempo total en traer un bloque de MP es: 64

10t pal. # % 640t bloque pal.


457

Las direcciones 0..4351 se corresponden con los bloques 0..67 (68 en total). Como en la memoria cache sólo caben 64 bloques, habrá que hacer sustituciones aplicando el algoritmo LRU: se sustituye, dentro de un conjunto, el bloque que ha sido usado menos recientemente. Primer ciclo de lectura (cache vacía): Tiempo debido a la gestión de fallos: En el primer ciclo de lectura, al estar la memoria cache vacía, se emplazan exitosamente los 64 primeros bloques (bloques 0 a 63, palabras 0 a 4095), que son los que caben en memoria cache. El estado de la memoria cache tras leer el bloque 63 se ilustra en la siguiente figura. A cada bloque B le corresponde el conjunto B mod nC % B mod 16. Dado un conjunto al que va destinado un bloque, el marco se escoge de forma asociativa.

Mapa de la memoria cache tras leer los primeros 64 bloques en la 1.a vuelta.

Por lo tanto, al bloque 64 le vuelve a corresponder el conjunto 16 mod 16 % 0, que está completo. Aplicando el algoritmo de sustitución LRU determinamos que el marco a sustituir es el 0, que es menos recientemente referenciado. Lo mismo ocurre con los bloques 65 a 67. Por lo tanto, el mapa de la memoria cache tras acceder a los 68 bloques queda como ilustra la figura.

458


Mapa de la memoria cache tras leer los 68 bloques en la 1.a vuelta.

Se han producido por tanto 68 fallos, es decir, traemos 68 bloques de MP a MC, por lo tanto, el tiempo de gestión de fallos viene dado por: Tfallos % 68 bloques # 64

pal. 10t # % 43.520t bloque pal.

Tiempo de lectura de MC: Dado que estamos leyendo 4.352 palabras en cada ciclo del programa, el tiempo de lectura suponiendo que todos los bloques se encuentran en MC vendrá dado por: Tcache % 4.352 pal. #

1t % 4.352t pal.

Tiempo total de lectura: Por lo tanto el tiempo de ejecución del primer ciclo será: T1 % Tfallos ! Tcache % 43.520t ! 4.352t % 47.872t Segundo ciclo de lectura: Tiempo debido a la gestión de fallos: En el segundo ciclo de lectura empezamos con el estado de la memoria cache que refleja la figura anterior. Leemos la palabra 0 que se corresponde con el bloque 0, y que no se encuentra en memoria cache. Por lo tanto sustituimos el bloque 16 que es el menos recientemente refe-


459

renciado, quedando almacenados en el conjunto 0 los bloques 64, 0, 32, 48. Lo mismo ocurre cuando el programa alcanza los bloques 1, 2 y 3, que fueron sustituidos en los conjuntos 1, 2, y 3, respectivamente. Hasta aquí se han producido 4 fallos. Desde el bloque 4 y hasta el 15 no se producen fallos, debido a que estos bloques ya se encuentran en MC y no han sido sustituidos previamente. Llegamos al bloque 16, que no se encuentra en cache, pues ya ha sido sustituido en el conjunto 0. Realizamos por tanto una nueva sustitución. Lo mismo ocurre con los bloques 17, 18 y 19. 4 fallos más. Desde el bloque 20 hasta el bloque 31 no se producen fallos, pues ya están ubicados en los conjuntos 4 a 15, respectivamente. Y así sucesivamente. Es fácil deducir que en los conjuntos 0 a 3 se producen un total de 5 fallos en cada uno, y que en los conjuntos 4 a 15 no se producen fallos. La siguiente figura muestra un esquema de la evolución temporal de la memoria cache en todos los ciclos del programa. Podemos apreciar que el número de fallos es el mismo en la segunda vuelta y sucesivas.

Evolución temporal de la memoria cache.

Como se producen 5 fallos en 4 conjuntos, cada uno de los cuales origina la lectura desde MP de 64 palabras (el tamaño de un bloque): Tfallos % 5 # 4 # 64 pal. #

10t % 12.800t pal.

460


Tiempo de lectura de MC: El tiempo de lectura de la memoria cache es el mismo que el tiempo de lectura de la primera vuelta: 1t % 4.352t Tcache % 4.352 pal. # pal. Tiempo total de lectura: Por lo tanto el tiempo total viene dado por: T2 % Tfallos ! Tcache % 17.152t Del tercer al décimo ciclo son iguales al segundo. De donde: Tcache % T1 ! 9 # T2 % 47.872t ! 9 # 17.152t % 202.240t La mejora obtenida es por tanto: MEJORA % 100 #

TMP . Tcache 435.200t . 202.240t % 100 # % 53,53% TMP 435.200t

PROBLEMA 16 Se ejecuta el siguiente código C en una máquina con un procesador que dispone de una memoria cache de datos de 256 bytes con bloques de 4 palabras (de 32 bits cada una): int i,j,salto,vector[256]; ... for(i=0; i<10000; i++) for(j=0; j<256; j=j+salto) c = vector[j]+5;

Suponga que sólo se accede a la memoria cache de datos para acceder al vector, y se supone que los enteros son palabras. Se pide: a) ¿Cuál es la tasa de fallos cuando la memoria cache es de emplazamiento directo y salto%132? b) ¿Y si salto es 131? c)

¿Cambiaría algo si la memoria cache fuera asociativa por conjuntos de dos vías?

d) Suponiendo que la memoria cache de datos es 20 veces más rápida que la memoria principal y que el tiempo de acceso a memoria cache es de t ciclos, calcule el tiempo total de acceso a memoria en los casos a) y b). Solución: a) Antes de averiguar la tasa de fallos debemos saber el número de marcos de bloque con que cuenta la memoria cache. Hay una capacidad 256 B % 28 B en la memoria cache. Además se dice que un bloque ocupa 16 B (4 palabras de 32 bits % 4 # 4 B). Por lo tanto el número de marcos de bloque es: 28/24 % 24 % 16 bloques. Así pues un esquema de la memoria cache sería el siguiente:


Marco

461

Palabra

0

0

1

2

3

ñ ñ

ñ ñ

ñ ñ

ñ ñ

ñ ñ

15

60

61

62

63

Como se puede ver sólo podemos introducir un total de 64 palabras como máximo. Debemos tener en cuenta que un número entero en C ocupa 32 bits, es decir, una palabra. Por lo tanto la memoria cache podría en el mejor de los casos almacenar hasta 64 números enteros. Ahora hay que analizar el comportamiento del bucle interno. El bucle externo simplemente repite lo que hace el bucle interno varias veces. Se dice en el enunciado que la memoria es de emplazamiento directo. Vamos a ir viendo a qué elementos se accede. j % 0 r Elemento 1 j % 132 r Elemento 133 Por lo tanto accedemos a dos números del vector o palabras. La pregunta que debemos responder a continuación es a qué bloques de memoria principal corresponden estas palabras y dónde se ubicarían estos bloques en la memoria cache. Ya que el enunciado no lo dice suponemos por simplicidad que el vector se carga a partir de la dirección y bloque 0 de MP (memoria principal). Como no se dice nada suponemos también que la memoria cache está inicialmente vacía. j % 0 r Bloque 0 de memoria principal. r M % B mod nM % 0 mod 16 % 0 j % 132 r Bloque 33 de memoria principal (132/4 % 33) r M % 33 MOD 16 % 1 Podemos concluir que una vez traídos los dos bloques de memoria principal correspondientes a los accesos efectuados por el programa, estos se ubicarán en los marcos 0 y 1 de la memoria cache. No existen por lo tanto fallos de sustitución y sólo hay que tener en cuenta dos fallos forzosos en la primera iteración del bucle interno (durante la primera iteración del bucle externo). Los fallos de sustitución se descartan porque sólo se accede a dos palabras/enteros y en la cache hay espacio para 64 palabras/números. Repetidos estos accesos 10.000 veces (bucle exterior) se puede concluir por tanto que la tasa de fallos es aproximadamente cero. b) Ahora salto es igual a 131. Siguiendo un razonamiento análogo al anterior se trata de averiguar los elementos accedidos del vector al igual que los bloques de MP donde están contenidos para saber dónde se ubicarían una vez traídos a la memoria cache. j % 0 r Elemento 1 j % 131 r Elemento 132 Los bloques de memoria principal: j % 0 r Bloque 0 de memoria principal r M % B mod nM % 0 mod 16 % 0 j % 131 r Bloque 32 de memoria principal (131/4 % 32) r M % 32 mod 16 % 0

462


Ahora resulta que los dos accesos que se producen a MP debido a la lectura de dos números/palabras corresponden a dos bloques no consecutivos (el bloque 0 y el 32) de MP que han de ubicarse en el mismo marco de la memoria cache. Esto supone que hay que traer y expulsar sucesivamente bloques del marco cero de la memoria cache produciéndose dos fallos de conflicto en cada iteración del bucle interior. Repetidos estos accesos 10.000 veces (bucle exterior) podemos concluir por tanto que la tasa de fallos es exactamente uno. c)

Si la memoria cache se convierte en una cache asociativa por conjuntos de dos vías se soluciona el problema anterior y la tasa de fallos es aproximadamente 0 en los dos casos. Esto es así porque sólo se han de traer dos bloques distintos de memoria principal en todo el programa y ahora disponemos de dos marcos de bloque por conjunto, es decir, hay espacio suficiente para ubicar esos dos bloques en el mismo conjunto en caso de necesidad.

d) En primer lugar calculamos el tiempo de acceso para el caso a). Sabemos que el tiempo de acceso a memoria cache viene dado por la expresión: tacc % h # tc ! (1 . h) # (tc ! tp) % tc ! (1 . h) # tp donde tc es el tiempo de acceso a cache y tp es el tiempo de acceso a memoria principal. Con los datos del problema esto resulta en: tacc % t !

2 # (4 # 20t) % 1,008t 20.000

En caso de fallo traer un bloque a memoria cache cuesta lo mismo que traer 4 palabras por separado. Para el caso b) se realiza un razonamiento similar: tacc % t ! 1 # (4 # 20t) % 81t Como podemos ver con estos valores el hecho de tener una cierta organización u otra en la memoria cache puede influir de forma decisiva en el rendimiento general de un computador en determinadas aplicaciones. PROBLEMA 17 Sea el siguiente programa

que se ejecuta en un computador con una MP de 64 Kpalabras, dotado de una MC con emplazamiento directo de 1 Kpalabras y con bloques de 128 palabras. El tiempo de ciclo


463

de la memoria principal es 10t, el de la memoria cache es t y el tiempo de transferencia de un bloque de MP a MC es de 500t. a) Especificar el n.o de bits de los campos etiqueta, marco y palabra. b) Considerando solamente el tiempo de búsqueda en memoria de las instrucciones, calcular el tiempo necesario para la ejecución del programa y la ganancia con respecto a un computador sin cache. Solución: a) La memoria principal (MP) tiene 16 bits para poder cubrir las 64 Kpalabras, de estos 16 bits 7 se dedican a direccionar la palabra (128 palabras/bloque % 27 palabras/bloque), y el resto (9 bits a direccionar el bloque). La memoria cache (MC) utiliza 10 bits para contener las 1 Kpalabras indicadas (210 palabras). Esto indica que el campo etiqueta será de 16 . 10 % 6 bits. Con 7 bits para direccionar la palabra esto nos deja 16 . 10 . 7 % 3 bits para el marco. Como resultado quedan las siguientes anchuras en bits para los campos etiqueta, marco y palabra para ambos tipos de memoria: Memoria principal:

Memoria cache:

b.1) Sin memoria cache En primer lugar analizamos los accesos totales a memoria del bucle anterior dividiendo la ejecución de una vuelta en las distintas fases que comprende:

Así resultan para el bucle externo: 10 # (142 ! 1.500 ! 961) % 10 # 2.603 % 26.030 accesos

464


Entonces, para todo el fragmento de código: 6 ! 26.030 ! 300 % 26.336 accesos Por lo tanto, el tiempo total consumido sin cache para este bucle resulta: 26.336 # 10t % 263.360t b.2) Con memoria cache En el caso de un sistema con un nivel de cache, la cantidad de accesos básica será igual ya que el procesador siempre accede a memoria a través de la cache, pero tenemos que añadir el coste de transferencias de MP-MC por fallos en cache. Realizamos el estudio para las distintas fases del código anterior: Inicio: en los accesos a direcciones 17 a 22, hay un 1 fallo de cache al estar la cache vacía y se carga el bloque 0..127 en cache al fallar el acceso a la posición 17, Marco de Bloque 0. Distinguiremos entre la primera iteración y las restantes del bucle interno: a

1. iteración: En total hay 9 fallos, que son los siguientes: Accesos direcciones 23 a 164: hay 1 fallo de cache al acceder a la posición 128, que no se encuentra cubierta por el bloque 0 cargado anteriormente. Accesos del bucle interno a direcciones 165 a 239: 0 fallos para las 20 iteraciones al haber cargado el bloque en la secuencia de accesos anterior. Accesos direcciones 240 a 1200: hay 8 fallos de cache al acceder a las siguientes direcciones: 256 (traemos al marco de bloque 2 el rango 256..383) 384 (bloque 3, rango 384..511) 512 (bloque 4, rango 512..639) 640 (bloque 5, rango 640..767) 768 (bloque 6, rango 768..895) 896 (bloque 7, rango 896..1023) 1024 (sobrescribimos bloque 0, rango 1024..1151) 1152 (sobrescribimos bloque 1, rango 1152..1279). 2.a a 9.a iteraciones: En total hay 36 fallos, 4 cada iteración, que son los siguientes: Accesos direcciones 23 a 164: hay 2 fallo de cache al acceder a la posición 128 y a la 23 también, ya que el bloque 0 contiene ahora el rango 1024 a 1151 al comienzo de todas las iteraciones. Accesos del bucle interno a direcciones 165 a 239: sigue habiendo 0 fallos para las 20 iteraciones al haber cargado los dos bloques en la secuencia de accesos anterior durante los dos fallos. Accesos direcciones 240 a 1200: hay 2 fallos de cache al acceder a las siguientes direcciones 1024 (sobrescribimos bloque 0, rango 1024..1151) 1152 (sobrescribimos bloque 1, rango 1152..1279)


465

El resto de bloques (bloque 2 a bloque 7) contienen las posiciones de memoria correctas ya que se cargaron en la primera iteración y nunca se sobrescribieron posteriormente. Fin: en los accesos a direcciones 1201 a 1500, hay dos fallos de cache al acceder a las direcciones: 1280 (traemos al marco de bloque 2 el rango 1280..1407) 1408 (bloque 3, rango 1408..1535) En total, para la ejecución completa del fragmento de código hay: 1 ! 9 ! 36 ! 2 % 48 fallos Por tanto, el tiempo de ejecución de MP ! MC resulta: 48 # 500t ! 26.336t % 50.336t Finalmente, el tiempo de ejecución se reduce al tener MP ! MC con respecto al sistema sólo con MP un total de 263.360t/50.336t % 4,06 veces. PROBLEMA 18 Sea un ordenador con un procesador de 8 bits, con sistema de memoria de las siguientes características: Memoria principal de 4 GB, entrelazada simple de orden inferior con 16 módulos, tiempo de acceso de 32 ns. Memoria cache de dos módulos independientes (instrucciones y datos), capacidad de ambas caches de 64 KB, tiempo de acceso de 4 ns, bloques de 16 B, política de emplazamiento asociativo por conjuntos de dos bloques, política de actualización escritura inmediata sin ubicación, política de sustitución FIFO. En este computador se ejecuta el siguiente código: while (i < n) { total = total + precio[i]*cantidad[i]; i = i + 1; }

Si inicialmente, la memoria cache de datos se encuentra vacía: a) Indicar la correspondencia entre una dirección de memoria principal y una de memoria cache. b) Indicar la traza de los 3 primeros accesos, a los datos, realizada por este fragmento de código suponiendo que: Las variables i, n y total se almacenan en dos de los registros, inicializadas a 0. Los vectores precio y cantidad se almacenan a partir de las direcciones de memoria principal 8001816 y 7001816 respectivamente. Indicar además en cuáles de las anteriores referencias a la memoria principal producen fallos en la memoria cache, considerando las tres iteraciones del bucle.

466


c)

Calcular la tasa de aciertos de la memoria cache de datos para el anterior fragmento de programa.

d) Calcular el tiempo de ejecución del fragmento del programa anterior debido únicamente a los accesos a memoria. Solución: Una memoria entrelazada de orden inferior separa la memoria en diferentes módulos, de forma que direcciones consecutivas de memoria se encuentran en módulos consecutivos. Bajo esta configuración, se puede acceder a distintos módulos en paralelo. Como un bloque ocupa en este caso 16 B y disponemos de 16 módulos, podemos traer un bloque de memoria principal de una sola vez. a) Correspondencia entre dirección de MP y MC Tamaño de la memoria principal:

4 GB % 232 B

Tamaño de bloque:

16 B % 24 B

Número de bloques en MP:

Tamaño de la cache de datos: Número de marcos en MC:

Número de conjuntos en MC:

nB %

232 B % 228 bloques B 24 bloque

64 KB % 26 # 210 B % 216 B nM %

nC %

216 B % 212 bloques B 24 bloque

212 bloques % 211 conjuntos bloques 21 conjunto

Un bloque de memoria principal se ubica en el conjunto correspondiente a la posición B mod nC % B mod 211 de memoria cache de datos, siendo B el número de bloque de memoria principal. Como la longitud de la dirección es de 32 bits, el campo palabra es de 4 bits y el campo conjunto es de 11 bits, podemos concluir que el campo etiqueta será de 32 . 11 . 4 % 17 bits, tal como se muestra en la siguiente figura:

b) Traza de tres primeros accesos La tabla siguiente muestra la traza de los tres primeros accesos. En la dirección de memoria principal, los dígitos en negrita representan el conjunto, mientras que los dígitos en negrita y cursiva representan la palabra. La dirección de memoria cache se divide en los campos etiqueta, conjunto y palabra, todos en decimal. Dado que disponemos de un procesador de 8 bits (1 B), elementos consecutivos de un vector estarán en posiciones consecutivas de memoria:


DIR. MC

467

Variable

DIR. MP

Acierto

precio[0]

8001816 0..01 0000 000 0000 0001 10002

Etiqueta: 16 Conjunto: 1 Palabra: 8

Fallo de lectura

cantidad[0]

7001816 0..00 1110 000 0000 0001 10002


Fallo de lectura

precio[1]

8001916 0..01 0000 000 0000 0001 10012


Acierto de lectura

cantidad[1]

7001916 0..00 1110 000 0000 0001 10012


Acierto de lectura

precio[2]

8001A16 0..01 0000 000 0000 0001 10102


Acierto de lectura

cantidad[2]

7001A16 0..00 1110 a000 0000 0001 10102

Etiqueta: 14 Conjunto: 1 Palabra

Acierto de lectura

c) Tasa de aciertos La tasa de aciertos vendrá dada por el número de aciertos que se producen al acceder sobre el número de accesos totales. Del apartado anterior podemos concluir que Tasa de aciertos % 4/6 % 0,6667 % 66,67% d) Tiempo de ejecución Los dos primeros accesos (ver apartado b) implican acceder a memoria cache a buscar la información y al no encontrarla se debe acceder a memoria principal a llevar el bloque a la cache. Como es entrelazada simple de orden inferior de 16 módulos podemos leer un bloque entero en un acceso. Por lo que los dos primeros accesos tienen un acceso a memoria cache y otro a memoria principal. Los siguientes accesos son aciertos por lo que solamente se accede a la cache. Por tanto son 6 accesos a cache y 2 a memoria principal: T % 6 # 4 ns ! 2 # 32 ns % 88 ns PROBLEMA 19 El sistema de memoria virtual de un computador tiene 16 MB de capacidad, y dispone de una memoria física de 512 KB. El tamaño de página es de 4 KB y se realizan las siguientes referencias a páginas virtuales (se referencian todas las palabras contenidas en cada página): 17, 13, 9, 17, 17, 24, 25, 25, 25, 13, 13, 14, 15, 15, 13, 13, 24, 24, 36, 37 y 40. Se pide:

468


a) Tamaño de la tabla de páginas. b) Número total de accesos a memoria principal suponiendo que inicialmente la tabla de páginas está vacía. c) Número total de accesos a memoria principal suponiendo que inicialmente la tabla de páginas está vacía y que se dispone de un TLB de 32 entradas con una correspondencia totalmente asociativa. d) Si un acceso a memoria principal tarda t unidades de tiempo y se tarda 106t unidades de tiempo en leer una página de disco, ¿qué mejora en el tiempo de acceso produce el uso del TLB? Calcúlese este factor teniendo en cuenta el acceso a disco y sin tenerlo en cuenta. NOTA: Se considerarán accesos a memoria todos aquellos accesos del programa de usuario así como los producidos por la actualización de la tabla de páginas y la carga de una página en memoria principal. Solución: a) Tamaño de la tabla de páginas N.o de páginas en MV % 16 MB / 4 KB % 224 / 212 % 212 % 4.096 páginas r Entradas en la tabla de páginas % 4.096 Cada entrada contiene (como mínimo) 1 bit de presencia ! bits del marco de página N.o de páginas en MP % 512 KB / 4KB % 219 / 212 % 27 % 128 páginas r bits de marco de página % 7 bits Por lo tanto: Tamaño de la TP % 4.096 # (7 ! 1) % 37.768 bits % 4 KB b) Número de accesos a MP N.o de fallos de página % 10 (existen 10 páginas diferentes en la secuencia del enunciado) Accesos en cada fallo: 1 a TP 212 para llevar la página a MP (4 KB) 1 para actualizar TP 1 para acceder a TP y obtener la dirección de MP 1 para acceder a la posición deseada Total: 4 ! 212 r N.o total de accesos en fallos % 10 # (4 ! 212) % 41.000 Accesos en cada acierto: 1 a TP 1 a posición deseada Total: 2


469

N.o de aciertos % N.o de referencias total . N.o de fallos % N.o de páginas del programa # tamaño de página N.o de aciertos % 21 # 212 . 10 % 86.006 N.o total de accesos en los aciertos % 86.006 # 2 % 172.012 N.o total de accesos a memoria % 41.000 ! 172.012 % 213.012 c)

Número total de accesos a memoria con TLB de 32 entradas TLB % 32 entradas r capacidad para soportar las entradas de TP correspondientes a las páginas del programa. En fallos se produce el mismo n.o de accesos a MP (1 ! 212 ! 1 ! 1 ! 1) En aciertos se produce un solo acceso a MP. El correspondiente a la posición deseada, el otro se realiza sobre TLB. N.o total de accesos a MP % 41.000 ! 86.006 % 127.006

d) Mejora al usar TLB, teniendo en cuenta el acceso al disco Teniendo en cuenta el acceso al disco Tiempo con TLB % 10 # 106t ! 127.006t Tiempo sin TLB % 10 # 106t ! 213.012t Tiempo con TLB/Tiempo sin TLB % 0,9916 r 99,16% Sin tener en cuenta el acceso al disco: Tiempo con TLB % 127.006t Tiempo sin TLB % 213.012t Tiempo con TLB/Tiempo sin TLB % 0,5962 r 59,62% PROBLEMA 20 Sea un computador con memoria virtual paginada y memoria cache con las características siguientes: Tamaño de página: 16 KB cada una (las palabras son de 1 B). Memoria virtual: 1 MB con traducción asociativa y sustitución LRU. Memoria física: 64 KB. Memoria cache de 256 B, asociativa por conjuntos, con bloques de 64 B, 2 bloques por conjunto y sustitución LRU (mediante registros de edad). El tiempo de acceso a la cache es Tc, el tiempo de acceso a memoria principal es Tm, tiempo de transferencia de un bloque de memoria principal a memoria cache es Tb y el tiempo de transferencia de una página de memoria secundaria a memoria principal es Tp. Se pide: a) Indicar el formato de la dirección virtual y de la dirección física. Calcular el número de páginas que contiene la memoria virtual y la memoria principal, así como el número de bloques que contiene la memoria principal y la memoria cache.

470


b) Calcular el número de bits necesarios para implementar la memoria cache (incluyendo datos, etiquetas y registros de edad) y el número de bits necesarios para implementar la tabla de páginas asociativa. c) Si en un momento dado los contenidos de la tabla de páginas y de la cache (en decimal) son los siguientes: Tabla de páginas asociativa

Etiquetas en la cache

N.o de página

N.o de marco

Etiqueta

Conjunto

Bloque

5 24 63 50

0 1 2 3

18 259 130 511

0 0 1 1

0 1 0 1

Expresar en hexadecimal el rango de direcciones virtuales y físicas ubicadas en cada marco de página de la memoria principal, así como el rango de direcciones virtuales y físicas ubicadas en cada bloque de la memoria cache. d) Supongamos que un programa realiza la siguiente cadena de referencias virtuales para lectura (en hexadecimal): 14910-1492F, 60170-6018F, CBFF0, 60190-6019F, 1100111F. Calcular el tiempo total de acceso a memoria para satisfacer esa cadena de referencias, suponiendo que inicialmente los contenidos de la cache son los que se muestran en la tabla anterior. Indicar claramente cómo evolucionan los contenidos de la memoria principal y de la memoria cache (indicando las direcciones virtuales que se ubican en cada bloque y los cambios en las etiquetas), cuando se realiza la cadena de referencias anterior. Solución: a) Formatos y número de páginas La dirección virtual (DV) es de 1 MB % 220 B y tiene por tanto 20 bits. Además, el tamaño de página es de 16 KB % 214 B, por lo que se utilizan 14 bits para el desplazamiento, y quedan entonces 6 bits para indicar el número de página.

En la misma línea, la dirección física (DF) es de 64 KB % 216 B y por tanto necesita 16 bits. Por tanto, con respecto a la memoria virtual (MV) la dirección física necesita de 14 bits para el desplazamiento y 16 . 14 % 2 bits para indicar el marco de página.


471

Desde el punto de vista de la memoria cache (MC), un bloque consta de 64 B % 26 B. El número de conjuntos se puede calcular fácilmente mediante la siguiente ecuación: 256 B B 64 bloque % 2 conjuntos nC % bloques 2 conjunto De donde la DF necesita de 6 bits para indicar la palabra, 1 bit para el conjunto y 16 . 1 . 6 % 9 bits para la etiqueta.

b) Número de bits necesarios para implementar la MC y la tabla de páginas (TP) La Tabla de Páginas (TP) Asociativa tiene una entrada por cada marco de página en MP, posee por tanto 4 entradas (64 KB de tamaño de MP/16 KB por página). Además, cada entrada está compuesta por el número de página en la DV (6 bits) y el marco de página en la DF (2 bits) (ver apartado anterior). Con esto resulta: Tamaño de la TP: 8 bits/registro # 4 registros % 32 bits Con respecto a la MC, al utilizar una política LRU con 2 % 21 marcos por conjunto, utilizamos un registro de edad que sólo requiere 1 bit. Por tanto, el tamaño de cada marco de bloque en la MC con algoritmo LRU es: Etiqueta: 9 bits. Registro de edad: 1 bit. Datos: 64 bytes. Como tenemos 4 marcos de bloque en MC, podemos concluir: Tamaño de MC: 4 # (9 ! 1 bits) ! 4 # 64 B % 5 B ! 256 B % 261 B (2.088 bits) c)

Rango de DV y DF en cada marco de página y en cada marco de bloque Tabla de páginas Como el esquema de una DV es 6 bits de página y 14 bits para el desplazamiento, el rango de DV para esta página será (en binario y hexadecimal): Rango en binario

Rango en hexadecimal

Página r 5 000101 00000000000000..000101 11111111111111

14000..17FFF

472


Podemos operar de la misma forma para el resto de las páginas de la tabla de páginas, quedando: Página r 5 000101 00000000000000..000101 11111111111111

14000..17FFF

Página r 24 011000 00000000000000..011000 11111111111111

60000..63FFF

Página r 63 111111 00000000000000..111111 11111111111111

FC000..FFFFF

Página r 50 110010 00000000000000..110010 11111111111111

C8000..CBFFF

Para el caso de las direcciones físicas, disponemos de los marcos 0, 1, 2, 3 en la tabla de páginas. Dado que el marco de página está compuesto de dos bits y el desplazamiento de 14 bits, podemos proceder de forma similar a la anterior: Rango en binario

Rango en hexadecimal

Marco de página r 0 00 00000000000000..00 11111111111111

0000..3FFF

Marco de página r 1 01 00000000000000..01 11111111111111

4000..7FFF

Marco de página r 2 10 00000000000000..10 11111111111111

8000..BFFF

Marco de página r 3 11 00000000000000..11 11111111111111

C000..FFFF

Memoria cache En el caso de la MC vemos cómo resulta la traducción de direcciones de MP a MC según la primera entrada de la tabla, considerando 9 bits para la etiqueta, 1 para el conjunto y 6 para la palabra: Etiqueta

Conjunto

Bloque

18

0

0

Rango en binario 000010010 0 000000 000010010 0 111111

Rango en hexadecimal 0900 093F


473

Podemos proceder de forma similar con el resto de entradas de la memoria cache: 18

0

000010010 0 000000 000010010 0 111111 259

0 0900 093F

0

100000011 0 000000 100000011 0 111111 130

1 8180 81BF

1

010000010 1 000000 010000010 1 111111 511

0 4140 417F

1

111111111 1 000000 111111111 1 111111

1 FFC0 FFFF

Finalmente comprobamos cómo resulta la traducción de direcciones de MC a direcciones de MV según la TP. En el caso de la etiqueta 18, ubicada en el conjunto 0, bloque 0 de MC, está en las direcciones físicas 090016 a 093F16. Como las direcciones físicas son de 16 bits, los dos bits más significativos de este rango son 002, lo que se corresponde con el marco de página 0. Según la tabla de páginas, al marco de página 0 le corresponde la página 5. Uniendo a este número de página el campo desplazamiento (14 bits) contemplado en el rango 090016 a 093F16, resulta en el rango de direcciones virtuales: 00002 90016: 00002 93F16:

000101 00 1001 0000 0000, resultando en MV: 1490016 000101 00 1001 0011 1111, resultando en MV: 1493F16

que representa el rango de MV para el bloque ubicado en el marco 0, conjunto 0 de MC. Podemos proceder de la misma manera para el resto de marcos de bloque de MC, quedando el mapa de MC como sigue: Rango en MP

Rango en MV

Rango en MV

Etiqueta 18, conjunto 0, marco 0 00002 90016 00002 93F16

000101 00 1001 0000 0000 000101 00 1001 0011 1111

14900 1493F

Etiqueta 259, conjunto 0, marco 1 10002 18016 10002 1BF16

111111 00 0001 1000 0000 111111 00 0001 1011 1111

FC180 FC1BF


011000 00 0001 0100 0000 011000 00 0001 0111 1111

60140 6017F

Etiqueta 511, conjunto 1, marco 1 11112 FC016 11112 FFF16

110010 11 1111 1100 0000 110010 11 1111 1111 1111

CBFC0 CBFFF

474


d) Ejecución de: 14910-1492F, 60170-6018F, CBFF0, 60190-6019F, 1100-111F Para seguir la evolución de esta ejecución, realizamos una traza de los distintos intervalos utilizando los resultados del apartado anterior: Intervalo 14910-1492F Como podemos apreciar en el apartado anterior (ver columna «Rango en MV»), todas estas direcciones se encuentran cargadas en memoria cache. Por lo tanto el tiempo de ejecución en este caso será: T1 % 32 # tc Intervalo 60170-6018F Como se puede apreciar en el mapa de la memoria cache (ver apartado anterior), las direcciones de este intervalo contenidas en memoria cache van desde 60170 a 6017F, todas en el conjunto 1, marco 0. Traducción de direcciones en el intervalo de MV 60180 a 6018F a dirección física

60180 r 0110 0000 0001 1000 0000 r Página 24 r Marco de página 1 6018F r 0110 0000 0001 1000 1111 r Página 24 r Marco de página 1 Por lo tanto este rango se encuentra en MP. Como hay que traerlo a MC, para averiguar el conjunto al que pertenece, basta con traducir el rango a direcciones físicas:

60180 r 0110 0000 0001 1000 0000 r 0100 0001 1000 0000 r 4180 6018F r 0110 0000 0001 1000 1111 r 0100 0001 1000 1111 r 418F Traduciendo estas direcciones al formato de memoria principal, tenemos:

4180 r 010000011 0 000000 r Conjunto 0 418F r 010000011 0 001111 r Conjunto 0 Esto quiere decir que para leer las DV en el rango pedido (60180-6018F), se deben traer de MP a MC las direcciones físicas de la etiqueta 131, conjunto 0 (direcciones físi-


475

cas 4180-418F), y se trae de memoria MP a MC el bloque 262, cuyo rango de direcciones físicas es en realidad (al ser de 64 bytes cada bloque): 010000011 0 000000.. 010000011 0 111111 r 4180..41BF Como estamos aplicando el algoritmo LRU, se sustituye el marco 1 del conjunto 0, porque el marco 0 ha sido referenciado anteriormente. En este caso la memoria cache queda como sigue: Rango en MP

Rango en MV

Rango en MV


000101 00 1001 0000 0000 000101 00 1001 0011 1111

14900 1493F


011000 00 0001 1000 0000 011000 00 0001 1011 1111

60180 601BF


011000 00 0001 0100 0000 011000 00 0001 0111 1111

60140 6017F


110010 11 1111 1100 0000 110010 11 1111 1111 1111

CBFC0 CBFFF

En consecuencia, el tiempo de ejecución de este intervalo se divide en dos: El debido al sub-intervalo que se encuentra en MC y el que está en MP. Tenemos entonces: T2 % (16 # tc) ! (tm ! tb ! 16 # tc) % tm ! tb ! 32 # tc Intervalo CBFF0 Esta dirección se encuentra directamente en MC, por lo que el tiempo de ejecución es: T3 % tc Intervalo 60190-6019F Son 16 palabras que ya se encuentran en MC, por lo que el tiempo de ejecución es: T4 % 16 # tc Intervalo 01100-0111F En este caso el intervalo completo no se encuentra en memoria cache. Traducimos las direcciones en el intervalo a dirección física:

476


01100 r 0000 0001 0001 0000 0000 r Página 0 r No está en MP (ver tabla de páginas) 0111F r 0000 0001 0001 0001 1111 r Página 0 r No está en MP (ver tabla de páginas) Por lo tanto tenemos que llevar la página 0 de memoria secundaria a memoria principal. Hay que comprobar las secuencias de referencias a páginas para ver cuál debemos sustituir: 14910..1492F r 0001 0100 1001 0001 0000 .. 0001 0100 1001 0010 1111 r Página 5 60170..6018F r 0110 0000 0001 0111 0000 .. 0110 0000 0001 1000 1111 r Página 24 CBFF0

r 1100 1011 1111 1111 0000 ................................................ r Página 50

60190..6019F r 0110 0000 0001 1001 0000 .. 0110 0000 0001 1001 1111 r Página 24 Podemos comprobar que la página 63 no ha sido referenciada, y por tanto sustituimos la página 63 por la página 0, quedando como sigue: Tabla de páginas asociativa N.o de página

N.o de marco

5 24 0 50

0 1 2 3

De este modo, las direcciones virtuales traídas a MP son (página 0): 00000 00000000000000 r 00000 r Página 0 r Marco de página 2 00000 11111111111111 r 03FFF r Página 0 r Marco de página 2 Por lo tanto este rango se encuentra ya en MP. Ahora hay que traerlo a MC. Para averiguar el conjunto al que pertenece, basta con traducir el rango a direcciones físicas:

01100 r 0000 0001 0001 0000 0000 r 1001 0001 0000 0000 r 9100 0111F r 0000 0001 0001 0001 1111 r 1001 0001 0001 1111 r 911F Traduciendo estas direcciones al formato de memoria principal, tenemos:

9100 r 100100010 0 000000 r Conjunto 0 911F r 100100010 0 011111 r Conjunto 0


477

Esto quiere decir que para leer las DV en el rango pedido (01100-0111F), se deben traer de MP a MC las direcciones físicas de la etiqueta 290, conjunto 0 (direcciones físicas 9100-911F), y se trae de memoria MP a MC el bloque 580, cuyo rango de direcciones físicas es en realidad (al ser de 64 bytes cada bloque): 100100010 0 000000..100100010 0 111111 r 9100..913F Como estamos aplicando el algoritmo LRU, se sustituye el marco 0 del conjunto 0, porque el marco 1 ha sido referenciado anteriormente. En este caso la memoria cache queda como sigue: Rango en MP

Rango en MV

Rango en MV


000000 01 1001 0000 0000 000000 01 1001 0011 1111

01900 0193F


011000 00 0001 1000 0000 011000 00 0001 1011 1111

60180 601BF


011000 00 0001 0100 0000 011000 00 0001 0111 1111

60140 6017F


110010 11 1111 1100 0000 110010 11 1111 1111 1111

CBFC0 CBFFF

En consecuencia, el tiempo de ejecución de este intervalo se corresponde con traer una página de memoria secundaria y un bloque de memoria principal. Tenemos entonces: T5 % tp % tm ! tb ! 32 # tc El tiempo total será por tanto la suma de estos cinco tiempos: 5

T % ; Ti %(32 # tc) ! (tm ! tb ! 32 # tc) ! (tc) ! (16 # tc)!(tp !tm !tb !32#tc) i%1

de donde finalmente se obtiene: T % tp ! 2 # tm ! 2 # tb ! 113 # tc PROBLEMA 21 Diseñar una memoria de 64 K # 20 bits a partir de pastillas de RAM de 8 K # 8 bits y 32 K # 1 bit. Solución: Una memoria de 64 K % 216 necesita de 16 bits para direccionar cualquier palabra (A15 A14 A13 ... A0). Al disponer las pastillas en forma matricial, necesitamos usar, para reducir espa-

478


cio, 8 filas # 2 columnas de pastillas de 8 K # 8 bits (3 columnas sobrepasaría el tamaño de la palabra, que es de 20 bits), lo que hace 64 Kpalabras de 16 bits/palabra. Para completar los 20 bits añadimos 2 filas # 4 columnas de pastillas de 32 K # 1 bit lo que completan las 64 Kpalabras de 20 bits por palabra. Para seleccionar una palabra en las pastillas de 8K % 213, utilizamos los 13 bits menos significativos (A12 ... A0), mientras que la selección de una fila u otra (de las ocho posibles) se realiza con los 3 bits restantes utilizando un decodificador. En el caso de las pastillas de 32K % 215, se procede de la misma forma, los 15 bits menos significativos de la dirección (A14 ... A0) seleccionan la palabra mientras que el bit más significativo selecciona una fila u otra. La siguiente figura muestra un esquema de diseño de lo anteriormente mencionado:

12.5 Problemas propuestos PROBLEMA 1 En un procesador con 10 ns de periodo de reloj, se tiene una cache con una tasa de fallos de 0,05, y una penalización por fallo de 20 ciclos de reloj. Calcular el tiempo medio de los accesos a memoria en función del número N de ciclos que se invierte en un acierto. Suponiendo que se pueda mejorar la tasa de fallo a 0,03 pero aumentando 2 ciclos el tiempo de acceso a la cache. ¿Se consigue mejorar el tiempo medio de acceso a memoria? PROBLEMA 2 Se tiene un computador A, con una cache de 4 vías con 256 entradas en cada vía. El tamaño total de la memoria que almacena las etiquetas de la memoria cache es de 16 Kbits. La memo-


479

ria que almacena los datos en la cache es de 64 Kbits. ¿Cuál es la organización de la memoria principal (profundidad y anchura) en el computador A? Se tiene un segundo computador B, con una cache con la misma estructura y tamaño que el A. La memoria cache B, sin embargo, carga un bloque de 4 palabras cada vez que se produce un fallo de cache (intenta aprovechar el principio de localidad espacial) ¿Cuál es la organización de la memoria principal (profundidad y anchura) en el computador B? PROBLEMA 3 Considere el siguiente trozo de código C: for(j=0;j<100;j=j+1) for(i=0;i<5000;i=i+1) x[i][j]=2*x[i][j];

Dicho código es perfectamente correcto desde el punto de vista lógico, pero ¿cómo podría mejorarse desde el punto de vista de la jerarquía de memoria? PROBLEMA 4 Sea una memoria principal de 264 palabras y una memoria cache de 26. Sabiendo que la memoria principal tiene unos tiempos de acceso de 150 ns, la memoria cache unos tiempos de acceso de 8 ns y sabiendo que la MP se divide en 262 bloques, calcular: a) Formato de la dirección cache para la política de emplazamiento directo, formato para la política de emplazamiento asociativo. b) Formato para la política de emplazamiento asociativa por conjunto sabiendo que es una memoria cache de 4 vías. c)

Tiempo de trabajo de la cache sabiendo que la tasa de fallos es del 20%.

d) Sabiendo que el tamaño de dirección virtual es el mismo que de dirección real y que una página es de 29 palabras, dar el formato de la dirección virtual. e)

¿Cuántas páginas puede tener un proceso activo?

f)

Suponiendo que el sistema operativo reserva 258 posiciones de memoria para virtualizar la memoria, ¿cuántos procesos activos puede haber simultáneamente en el sistema.

PROBLEMA 5 Un computador dispone de un sistema de memoria central constituido por una memoria principal MP de 4 MB y una memoria cache MC de 32 KB. La MC tiene un tamaño de línea de 8 bytes, un grado de asociatividad de 4 y una política de sustitución LRU. La MP está diseñada como memoria entrelazada de orden inferior de manera que direcciones consecutivas se encuentran ubicadas en módulos consecutivos y con un número de módulos tal que permita minimizar el tiempo de transferencia de bloques entre MP y MC. Se pide: a) Número de módulos de MP y tamaño de los mismos. b) Interpretación de los bits de la dirección física del sistema de memoria para MP. c)

Interpretación de los bits de la dirección física del sistema de memoria para MC.

480


d) Si un programa referencia direcciones pertenecientes a los bloques: 63, 64, 128, 1025, 1026, 1027, 2049, 127, 340, 4097, 1025, 1024, 6145, 6147, 6148, 3073, 128, 0, 125, determinar el contenido de los bits de etiqueta correspondientes al conjunto 1. PROBLEMA 6 En un computador que dispone de un sistema de memoria central con una memoria principal MP de 64 Kpalabras y una cache de datos MC de 128 palabras con correspondencia asociativa de 2 vías y 8 palabras por bloque, se ejecuta el siguiente programa: for(j=0; j<16; j=j+1) for(i=0; i<2; i=i+1) z[i][j] = (x[i][j]+y[i][j])/2;

El tiempo de acceso a MP es 10 veces superior al de MC, que es de 5 ns. Suponiendo que los arrays x[i][j], y[i][j], z[i][j] son ubicados en posiciones consecutivas de memoria a partir de la dirección 0, uno a continuación de otro, ordenados por filas, y que sus elementos están codificados con 4 palabras: a) Calcular el tiempo total de acceso a los arrays x[i][j], y[i][j], z[i][j] durante la ejecución del programa sabiendo que en MC opera una política de escritura directa (write through) sin asignación en cache. b) Calcular la ganancia de velocidad (speedup) del programa que resulta de intercambiar los bucles i y j respecto a la versión original. c)

Si el programa anterior es parte de una aplicación en la que el acceso a los arrays x[i][j], y[i][j], z[i][j] supone el 30% del tiempo total de ejecución de la aplicación, calcular la ganancia de velocidad (speedup) de la aplicación cuando se introduce el intercambio de bucles.

NOTA: Se supone que todas las referencias del programa a los arrays x[i][j], y[i][j], z[i][j] son convertidas por el compilador en accesos al sistema de memoria (MC-MP), sin la utilización de registros internos. PROBLEMA 7 Se desea conectar a un microprocesador de 32 líneas de dirección (A31...A0) una memoria ROM de 8 Kpalabras y una memoria RAM de 128 Kpalabras de manera tal que la ROM se ubique en la zona más baja del espacio de direcciones y la RAM en las direcciones contiguas a la ROM. Calcular las funciones lógicas de selección respectivas. PROBLEMA 8 Un computador dispone de 128 MB de memoria virtual, 16 MB de memoria principal y 128 KB de memoria cache. Se pide: a) Indicar la codificación de la dirección de la memoria virtual para los siguientes casos: Memoria virtual paginada con tamaño de página de 4 MB. Memoria virtual segmentada con tamaño máximo de segmento de 16 MB. Memoria virtual paginada segmentada con páginas de 4 MB y tamaño máximo del segmento de 16 MB.

481


b) Si la memoria cache presenta 2 vías y un tamaño del marco de bloque de 16 KB, además de los siguientes valores de las tablas de memoria virtual (re-emplazamiento FIFO) y memoria cache (reemplazamiento LRU). Indicar detalladamente qué ocurre cuando se accede consecutivamente a las siguientes direcciones de memoria virtual: 5A341B1, 0404AFF, 10FFFFF.

c)

N.o pág.

M pág.

FIFO

Etiqueta

Conj.

Vía

LRU

16

0

2

23

0

0

1

5A

1

3

10

0

1

0

52

2

0

43

1

0

0

04

3

1

18

1

1

1

23

2

0

1

52

2

1

0

04

3

0

0

23

3

1

1

Indicar el conjunto de direcciones tanto de memoria principal como de memoria virtual del marco de bloque con etiqueta 04.

a

Al diseñar un computador, uno de los puntos a tener en cuenta es el diseño del sistema de entrada-salida, ya que de él dependerá el rendimiento con el que el computador se comunicará con los periféricos, y en definitiva, con el mundo exterior. En la siguiente figura se ilustra un esquema general de entrada/salida.

Antes de empezar a hablar sobre lo que son los métodos y técnicas de entrada y salida de datos debemos conocer los principios de éstas, por lo cual es conveniente hablar sobre el medio de transporte de la información, tal y como lo es el bus de direcciones, para que una vez

484


comprendido el concepto de éste nos sea más fácil entender los términos y el contenido en general sobre la entrada y salida de datos.

13.1 Bus de direcciones Es utilizado por el microprocesador para señalar la celda de memoria (o el dispositivo de E/S) con el que se quiere operar. El tipo de operación será de lectura o de escritura y los datos implicados viajarán por el bus de datos. Por él circula la expresión binaria de la dirección de memoria a la cual el microprocesador quiere acceder. Tiene sentido de flujo unidireccional desde el microprocesador hacia la memoria. Una vez localizados los datos perdidos, su transmisión hacia el microprocesador (o hacia donde sea) se hará a través del bus de datos. Los dispositivos de E/S intercambian la información con el microprocesador mediante los puertos de E/S. Cada puerto está asociado con un determinado dispositivo y tiene una dirección que lo identifica. El ancho de este bus también es una medida de la potencia del microprocesador, ya que determina la cantidad de memoria a la que éste puede acceder, es decir, la cantidad de espacio direccionable. El espacio de direcciones es el rango de valores distintos que el microprocesador puede seleccionar. La cantidad máxima de direcciones disponibles será 2n, siendo n el número de líneas del bus de direcciones.

13.2 Módulos de E/S Los periféricos los hay de entrada, de salida y de entrada-salida. Destinados a la comunicación con el ser humano o con otros computadores, pero todos ellos constan de dos partes claramente diferenciadas: el controlador y el dispositivo. El controlador del periférico es el encargado de la comunicación con la CPU. El que lleva a cabo el protocolo de comunicación y el que realiza la transferencia de datos propiamente dicha. Los dispositivos de E/S se conectan al computador a través de un controlador de E/S. Cada controlador está a cargo de un tipo específico de dispositivo. Dependiendo del controlador, pueden estar varios dispositivos conectados al mismo controlador. El controlador se encarga de mover datos entre el dispositivo periférico que controla y el buffer de almacenamiento local. El tamaño del buffer varía de un controlador a otro y depende del dispositivo que controla. El dispositivo es realmente el periférico, electrónico una memoria USB, electromecánico como un disco duro, un transductor como en el caso de los sensores de temperatura o movimiento.

13.3 Gestión de la comunicación CPU-periféricos En la gestión de la comunicación de la entrada/salida se deben tener en cuenta tres aspectos que detallamos a continuación.

Capítulo 13 Entrada/salida

485

13.3.1 Selección del periférico Identificar el periférico entre todos los disponibles mediante el direccionamiento del mismo. Para comunicarse con un periférico la CPU debe seleccionarlo, indicar el sentido de la comunicación (lectura o escritura) y enviar los datos. Para seleccionar la dirección de un periférico (comúnmente denominado puerto), la CPU suele utilizar direcciones. Existen dos métodos generales para ubicar las direcciones de E/S: E/S aislada: los espacios de direccionamiento de puertos y de direcciones de memoria son diferentes por lo que se deberán incluir instrucciones propias de entrada-salida. Por ejemplo, en el i80x86 posee instrucciones IN y OUT. E/S localizada en memoria: El espacio de direcciones es común, es decir, tanto direcciones de memoria como de puertos de entrada-salida forman un espacio de direcciones común, por lo que las instrucciones del repertorio son las mismas para ambos tipos de transferencia (por ejemplo, MOVE X, Y para mover dato a registro o dato a periférico).

13.3.2 Gestión de las señales de control Determinar para cada tipo de sincronización y cada tipo de selección de periférico el conjunto de señales de control que deberán ser tenidos en cuenta por la Unidad de Control para la correcta gestión de la comunicación.

13.3.3 Sincronización con la CPU Se trata de evitar los problemas surgidos de las diferentes velocidades de trabajo de la CPU y de los periféricos, de evitar inundar al periférico con datos provenientes de la CPU y evitar que ésta se quede esperando los datos del periférico. Son posibles tres técnicas de sincronización: E/S programada. E/S mediante interrupciones. E/S mediante DMA.

13.4 E/S programada Los datos se intercambian entre la CPU y el módulo de E/S. La CPU ejecuta un programa que controla directamente la operación de E/S, incluyendo la comprobación del estado del dispositivo, el envío de la orden de lectura o escritura y la transferencia del dato. Cuando la CPU envía la orden debe esperar hasta que la operación de E/S concluya. Si la CPU es más rápida, ésta estará ociosa. La CPU es la responsable de comprobar periódicamente el estado del módulo de E/S hasta que encuentre que la operación ha finalizado.

486


Algoritmo de lectura y escritura mediante E/S programada para un único periférico.

13.5 E/S mediante interrupciones Los periféricos avisan a la CPU cuando están listos para ser atendidos. Cuando la interrupción es aceptada por la CPU, ésta abandona momentáneamente el programa principal para ejecutar la Rutina de Tratamiento de Interrupciones (RTI) y realiza la transferencia. Es necesario mencionar que antes de que se ejecute la correspondiente RTI se deben deshabilitar el resto de las interrupciones.

13.5.1 Petición de interrupción Para realizar la petición de interrupción existen diversas alternativas: Una única línea de petición de interrupción (INTR): A esta línea se conectan todos los periféricos. Varias líneas de petición de interrupción (INTRi): En este esquema cada uno o cada grupo de periféricos solicitan ser atendidos por una línea diferente.

13.5.2 Reconocimiento de interrupción A la hora de conceder una determinada petición de interrupción existen varias posibilidades.


487

Por encuesta software: Una vez recibida la petición de interrupción por INTR, la CPU utiliza un mecanismo de encuesta vía software para identificar el periférico que solicitó la interrupción. Una única línea de reconocimiento de interrupción (INTA): En este caso la CPU envía una señal cableada a todos los periféricos para indicar que se ha concedido la interrupción. Varias líneas de concesión (INTAi): La CPU envía una señal de reconocimiento al nivel que solicitó la interrupción.

13.5.3 Identificación del dispositivo Cuando la CPU concede la interrupción por alguno de los mecanismos anteriores, esta debe identificar el dispositivo que la solicitó para ejecutar la RTI correspondiente. Existen varias alternativas: Identificación software: Se dispone de una única RTI que realiza una encuesta a todos los periféricos para saber qué operaciones debe ejecutar. Identificación hardware: En este caso cada periférico o nivel (en el caso de tener varias líneas de petición de interrupción) dispone de un vector o autovector, respectivamente, a partir de los cuales se calcula la dirección de comienzo de la RTI correspondiente. Otros: En algunos casos, especialmente en las interrupciones por niveles, se dispone de una RTI por nivel que se obtiene mediante un vector o autovector. A continuación un mecanismo de encuesta software suele reconocer el periférico del nivel para ejecutar las operaciones oportunas.

13.5.4 Prioridades Existen muchos mecanismos para establecer prioridades entre interrupciones, los más utilizados son: Prioridad en orden: Es el orden de la encuesta software o la propagación de la señal INTA la que determina qué periférico será atendido en primer lugar. Codificadores de prioridad: Se pueden añadir codificadores de prioridad para establecer qué interrupción será atendida en primer lugar. Enmascaramiento selectivo: En algunas ocasiones se puede introducir un registro de máscara para descapacitar (vía puertas AND, por ejemplo) distintos niveles de interrupciones.

13.6 E/S DMA (Direct Memory Access) La E/S con interrupciones, aunque más eficiente que la E/S programada, también requiere la intervención de la CPU para transferir datos entre la memoria y el módulo de E/S. Sea el siguiente ejemplo: cuando se va a leer una línea desde un monitor, el primer carácter escrito es enviado al computador. Cuando el carácter es recibido por el controlador, éste

488


interrumpe a la CPU. La CPU le da servicio a la interrupción y luego continua con el proceso que estaba ejecutando. Esto es posible cuando el dispositivo es muy lento comparado con la CPU. Entre un carácter y otro la CPU lleva a cabo gran cantidad de procesamiento. Pero ¿qué sucede cuando estamos trabajando con dispositivos de E/S más veloces? Tendríamos interrupciones muy seguidas y se estaría desperdiciando mucho tiempo. Para evitar esto, se utiliza DMA para dispositivos de E/S de alta velocidad. El controlador del dispositivo transfiere un bloque de datos desde o para sus buffers de almacenamiento a memoria directamente sin intervención de la CPU. Sólo se produce una interrupción por bloque en lugar de tener una interrupción por cada byte (o palabra). Por ejemplo, un programa solicita una transferencia de datos. El Sistema de Operación busca un buffer disponible. El controlador de DMA tiene sus registros actualizados con las direcciones de la fuente y del destino y la longitud de la transferencia. Por lo general esta actualización es realizada por el manejador de dispositivo (rutina). Se indica al controlador de DMA a través de bits de control en un registro de control para que inicie la operación de E/S. Mientras tanto la CPU puede llevar a cabo otras operaciones. El controlador de DMA interrumpe la CPU cuando la transferencia ha sido terminada. La CPU interviene sólo al comienzo y al final de la transferencia. Algunos dispositivos de entrada/salida envían datos a la memoria más rápido de lo que el microprocesador puede manejar. El controlador de DMA es un circuito integrado dedicado que puede enviar y recibir datos más rápido que el microprocesador. Luego, dispositivos como discos ópticos y magnéticos utilizan este integrado para acceder a la memoria del sistema. Finalmente, también se dispone de entrada/salida mediante procesadores de entrada/salida. En este caso se emplea una CPU secundaria dedicada a la gestión de la operación de entrada/salida.

13.7 Problemas resueltos PROBLEMA 1 Determinemos el impacto de la sobrecarga de la encuesta en el caso de tres dispositivos diferentes suponiendo que el número de ciclos que requiere una operación de encuesta es 100 y que el procesador trabaja con un reloj de 50 MHz. Determinar la fracción de tiempo de CPU que se consume en cada uno de los 3 casos siguientes: a) El ratón debe ser encuestado 30 veces por segundo para asegurar que no se pierde ningún movimiento realizado por el usuario. b) El CD transfiere datos al procesador en unidades de 16 bits a una velocidad de 50 KB/s. No debe perderse ningún dato. c)

El disco duro transfiere datos en bloques de 4 bytes a una velocidad de 2 MB/s. No debe perderse ningún dato.

Solución: a) Ciclos de reloj por segundo para realizar la encuesta % 30 # 100 % 3.000 ciclos por segundo.


Fracción de ciclos de reloj consumidos por el procesador %

489

3.000 % 0,006% 50 # 106

Por tanto, la encuesta puede ser utilizada para el ratón sin mucho impacto en el rendimiento del procesador. b) Para el CD, la velocidad a la que se debe preguntar es: KB encuestas encuestas s % 25 K % 25 # 210 B s s 2 encuesta 50

Y por tanto, el número de ciclos es: 25 # 210

encuestas ciclos ciclos # 100 % 25,6 # 105 s s encuesta

Y finalmente: Fracción consumida por el procesador %

25,6 # 105 % 5% 50 # 106

Aunque el porcentaje es sustancial, aún puede ser tolerado en un sistema de bajas prestaciones. c)

Es similar al apartado anterior: MB ciclos s ciclos # 100 % 51,2 # 106 B encuesta s 4 encuesta 2

Fracción consumida por el procesador %

51,2 # 106 ] 100% 50 # 106

Por lo tanto la CPU estará totalmente ocupada encuestando al disco. PROBLEMA 2 Se dispone de un procesador que trabaja con un reloj de 50 MHz y de un CD que transfiere datos al procesador en unidades de 16 bits a una velocidad de 50 KB/s. A este sistema se le añade un controlador de interrupciones tal que el tiempo invertido en una transferencia es de 100 ciclos de reloj. Determinar la fracción consumida por el procesador cuando el CD está activo. Solución: La velocidad a la cual el CD debe interrumpir cuando está transfiriendo es:

490


KB ciclos ciclos s ciclos # 100 % 2.500 # 210 % 25,6 # 105 B s s interrupción 2 interrupción 50

Y por tanto: Fracción consumida por el procesador %

25,6 # 105 % 5% 50 # 106

La gran diferencia con la E/S programada es que el CD no está leyéndose el 100% del tiempo y por tanto el dispositivo no perturba a la CPU, al contrario que con la E/S programada, donde la CPU encuesta sin descanso a los dispositivos. Por ejemplo, si el CD está transfiriendo el 10% del tiempo total del sistema, la CPU será perturbada solamente el 0,5%. PROBLEMA 3 Se dispone de un procesador que trabaja con un reloj de 50 MHz y de un disco duro que transfiere datos en bloques de 4 bytes a una velocidad de 2 MB/s. A este sistema se le añade un controlador de DMA. Una transferencia de DMA utiliza 1.000 ciclos de reloj del procesador, y el tratamiento de interrupción tras la finalización de la transferencia necesita 500 ciclos de reloj. Si la transferencia media del disco es de 4 KB, determinar la fracción consumida por el procesador cuando el disco duro está activo. Solución: Cada transferencia de DMA utiliza: KB s transf. % 2 # 10.3 MB transf. 2 s

4

Si el disco está transfiriendo constantemente, éste requiere: ciclos ciclos transf. % 750 # 103 s s transf.

(1.000 ! 500) 2 # 10.3

Como el procesador es de 50 MHz: Fracción consumida por el procesador %

750 # 103 % 1,5% 50 # 106

PROBLEMA 4 En la siguiente figura se presenta un diagrama con el circuito de gestión de interrupciones de un sistema de E/S, tal que la prioridad es ascendente: prioridad INTR0 a INTR1 a a INTR2 a INTR3. Determine la expresión lógica que define INTR.


491

Solución: La figura muestra un sistema de gestión de interrupciones. En este caso no nos importa la gestión interna de las prioridades, ya que lo que pide el enunciado es el diseño lógico de la señal INTR. Esto es, independientemente de cómo se diseñen las prioridades, se producirá una solicitud de interrupción siempre que se active alguna de las señales INTRi (i % 0..3). Dicho esto la función asociada a INTR no es más que la suma lógica de las INTRi: INTR % INTR0 ! INTR1 ! INTR2 ! INTR3 PROBLEMA 5 Un computador tiene tres líneas de petición de interrupción de distinta prioridad: INTR0 a INTR1 a INTR2 y tres líneas de aceptación asociadas: INTA0, INTA1, INTA2. a) Obtener la tabla de verdad de las salidas INTA0, INTA1, INTA2 en función del valor de las entradas INTR0, INTR1, INTR2. b) Diseñar un circuito lógico que implemente ese esquema de prioridades. Solución: El sistema de gestión de interrupciones viene dado por la siguiente figura.

492


a) La tabla de verdad que resulta según las prioridades indicadas es la siguiente: INTR2

INTR1

INTR0

INTA2

INTA1

INTA0

0

0

0

0

0

0

1

X

X

1

0

0

0

1

X

0

1

0

0

0

1

0

0

1

de donde las funciones de conmutación que se obtienen son las siguientes: INTA2 % INTR2 INTA1 % INTR1 . INTR2 INTA0 % INTR0 . INTR1 . INTR2 b) El circuito lógico que resulta es un sistema combinacional puro simple que tiene la siguiente implementación:

PROBLEMA 6 Una CPU dispone de una línea de petición de interrupción (INTR) y de una línea de aceptación de interrupción (INTA). Se desea diseñar para esa CPU un controlador de interrupciones de forma que: Se pueda atender interrupciones generadas por 3 dispositivos externos mediante líneas de petición de interrupción (ver figura). Cuando se reciben peticiones de interrupción simultáneas, sólo se reconoce la más prioritaria. La mínima prioridad la tiene INTR0 y la máxima INTR2. Cada una de estas líneas de interrupción se ha de poder enmascarar de manera selectiva mediante un registro de máscara (M2M1M0) del controlador de interrupciones. Cuando la CPU activa su línea de aceptación, INTA, se debe informar al periférico correspondiente, de manera individual, que su petición ha sido aceptada utilizando las líneas de aceptación INTA2, INTA1, INTA0.


493

Controlador de interrupciones enmascarables.

a) Obtener la función lógica de las líneas INTR, INTA2, INTA1, INTA0 en función de las líneas INTR0, INTR1, INTR2, INTA y de los bits del registro de máscara. b) Diseñar el circuito lógico del controlador de interrupciones. c)

Diseñar una conexión de varios controladores de interrupciones de 3 entradas, como el diseñado en el apartado anterior, para poder atender las peticiones de interrupción de 7 periféricos externos.

Solución: a) La señal INTR se activa si alguna de las señales INTRi se activa y siempre y cuando su correspondiente bit de máscara Mi esté activo: INTR % INTR2 . M2 ! INTR1 . M1 ! INTR0 . M0 La obtención de las tres líneas de aceptación INTAi es casi inmediata teniendo en cuenta que: INTA2 se activa siempre y cuando la CPU haya concedido la petición, es decir, haya activado INTA, la petición del dispositivo 2 esté activa (INTR2 % 1) y este nivel no esté enmascarado (M2 % 1). INTA1 se activa si INTA % 1, si el dispositivo 1 ha solicitado una interrupción (INTR1 % 1 y M1 % 1) y el dispositivo 2 no lo ha hecho (INTR2 % 0 o M2 % 0). INTA0 se activa si INTA % 1, si el dispositivo 0 ha solicitado una interrupción (INTR0 % 1 y M0 % 1) y ni el dispositivo 1 ni el 2 lo han hecho (INTR1 % 0 o M1 % 0 y INTR2 % 0 o M2 % 0). A esta conclusión también se puede llegar construyendo las tablas de verdad. En cualquier caso resulta: INTA2 % INTA . INTR2 . M2 INTA1 % INTA . INTR1 . M1 . (INTR2 . M2) INTA0 % INTA . INTR0 . M0 . (INTR2 . M2) . (INTR1 . M1)

494


b) La siguiente figura muestra un posible diseño:

c)

La conexión de los controladores puede realizarse como se muestra en la siguiente figura:

Con la estructura mostrada en la figura anterior, el dispositivo más alejado de la CPU es el que tiene mayor preferencia. Cuando se produce una petición por cualquiera de las líneas INTRi, ésta se propaga por los controladores intermedios mediante sus líneas originales INTR2 hasta llegar a la CPU. De la misma forma, cuando la CPU activa su señal de reconocimiento de interrup-


495

ción INTA, los controladores intermedios propagan esta señal a través de la línea original de aceptación INTA2. PROBLEMA 7 Un procesador de 16 bits (direcciones y datos) dispone de una única línea de interrupción INTR con vector en la dirección FFFF16. El procesador no dispone de señal INTA, es decir, cuando decide conceder una interrupción, vuelca directamente la dirección del vector sobre el bus de direcciones. Diseñar un controlador de interrupciones para dotar al procesador de 4 líneas autovectorizadas INTR0, INTR1, INTR2 e INTR3 con prioridad ascendente (INTR0 la menos prioritaria e INTR3 la más prioritaria) con vectores en las direcciones FFFC16, FFFD16, FFFE16 y FFFF16 respectivamente. Solución: En este caso cuando el procesador concede una petición de interrupción, vuelca directamente la dirección del vector (FFFF16) sobre el bus de direcciones. Para introducir 4 líneas de petición de interrupción, basta con utilizar un codificador de prioridad 4 a 2:

Cuatro líneas de petición de interrupción.

De esta forma, si alguna de las líneas INTRi solicita una interrupción, el codificador pondrá su línea de activación (A) a 1 y en consecuencia se activará INTR. A continuación, la CPU volcará la dirección FFFF16 sobre el bus de direcciones, dirección que debemos modificar para obtener el valor correcto en función de la línea que haya solicitado la interrupción (FFFC16, FFFD16, FFFE16 y FFFF16). Como se puede apreciar, de las cuatro direcciones sólo habrá que modificar dos de los 16 bits.

496


La tabla de modificación del bus de direcciones es la siguiente: A15...A0

INTR3

INTR2

INTR1

INTR0

Añ1Añ0

FFFF

0 0 0 1

0 0 1 0

0 1 0 0

1 0 0 0

00 r A15...A0 % FFFC16 01 r A15...A0 % FFFD16 10 r A15...A0 % FFFE16 11 r A15...A0 % FFFF16

Por ejemplo, si interrumpe la línea 0 (INTR0) tendremos que modificar FFFF16 a FFFC16. Por el contrario, si interrumpe la línea 3, tendremos que dejar el bus de direcciones como está. Posteriormente, se dispondrá de una tabla de vectores para acceder a la dirección especificada y extraer la dirección de la RTI correspondiente. Un posible diseño consiste en utilizar puertas AND, OR, NOT para implementar el controlador, pero resulta mucho más sencillo si en lugar de esto utilizamos multiplexores y el codificador de prioridad anterior:

PROBLEMA 8 Una CPU tiene una longitud de palabra de 8 bits y cuenta con una sola entrada de petición de interrupción (INTR) y la correspondiente salida de reconocimiento (INTA). Se quiere dotar a la CPU de 4 niveles de petición de interrupción, en cada uno de los cuales puedan interrumpir 4 dispositivos periféricos. Diseñar la lógica de control de interrupciones que hay que añadir a la CPU de modo que: a) Se resuelvan las prioridades de los dispositivos del mismo nivel.


497

b) Se resuelvan las prioridades de los distintos niveles. c)

Se identifique el dispositivo mediante un vector de 8 bits. Describir el funcionamiento de la unidad diseñada.

Solución: Disponemos de cuatro niveles y cuatro dispositivos por nivel. Utilizaremos la siguiente nomenclatura: INTRij para denotar la petición de interrupción del periférico j por el nivel i. INTAij para denotar el reconocimiento de la interrupción del periférico j en el nivel i. INTRi para denotar la petición de interrupción por el nivel i. INTAi para denotar el reconocimiento de la interrupción al nivel i. Recuerda: La CPU comprueba si hay interrupciones pendientes (línea INTR activada) al final de la ejecución de cada instrucción. La secuencia básica a seguir es: 1.

El periférico activa INTR.

2.

La CPU activa la confirmación INTA.

3.

El periférico que ha solicitado la interrupción, si recibe INTA, propaga el número de vector por el bus de datos.

4.

La CPU ejecuta la RTI correspondiente al número de vector recibido.

Este esquema presenta algunas variantes en función del diseño que se lleve a cabo del tratamiento de interrupciones. a) En cuanto a la solicitud de interrupción por el mismo nivel, podemos establecer un esquema de prioridad ascendente, es decir, para el nivel i, INTRi0 a INTRi1 a INTRi2 a a INTRi3. Teniendo todo esto en cuenta, y utilizando codificadores de prioridad, el esquema hardware para un nivel dado i es el que sigue:

El codificador de prioridad codifica la entrada de mayor prioridad activa. Si al menos una entrada al codificador está activa, entonces A % 1. Si A % 0, significa que todas las

498


entradas al codificador están inactivas. Las salidas O1 y O0 las utilizaremos más adelante para generar el vector de interrupciones. De momento no son necesarias. b) Al igual que en el apartado anterior, en cuanto a la solicitud de interrupción por distintos niveles, podemos establecer un esquema de prioridad ascendente, es decir, INTR0 a INTR1 a INTR2 a INTR3 Para resolver la petición de interrupción entre distintos niveles basta con conectar las salidas INTRi (i % 0..3) del apartado anterior a un nuevo codificador de prioridad, de forma que la salida A de este codificador se corresponde con la entrada INTR a la CPU:

Según la figura, podemos observar que en cuanto uno de los niveles solicita una interrupción, la entrada A se activa y en consecuencia la CPU recibe la notificación (se activa INTR). De la señal INTA nos ocuparemos en el siguiente apartado. c)

Una vez que la CPU recibe INTR, ésta activará la señal INTA, y en consecuencia se leerá el número de vector correspondiente al periférico que solicitó la interrupción. Con el diseño que hemos venido desarrollando, y dado que se deja en nuestras manos la elección del número de vector, la codificación del vector va a ser sencilla. Hasta ahora no hemos utilizado las salidas O1 y O0 de los codificadores de prioridad, pero está claro que el número de vector puede tener la forma 0000XXYY, donde XX es la salida del codificador de niveles e YY es la salida del codificador de cuatro periféricos. Evidentemente INTA debe habilitar la salida de este número de vector. Una posible implementación por tanto puede ser la que se muestra en la figura de la pagina siguiente. Como se puede apreciar en dicha figura hemos obviado algunas implementaciones, como la del multiplexor y algunas agrupaciones de líneas. En cualquier caso podemos observar cómo la información del número de vector es generada únicamente si INTA está activa, debido al búfer triestado de la figura, que es habilitado mediante esta señal.


499

Implementación final.

PROBLEMA 9 Una CPU dispone de 8 líneas de datos, 16 líneas de direcciones, una línea de petición de interrupción INTR y una línea de reconocimiento INTA. Diseñar un controlador de interrupciones para dotar a este sistema de 4 niveles vectorizados enmascarables selectivamente, de tal forma que:

500


Los registros que almacenan los vectores forman parte del controlador de interrupciones y pueden leerse y escribirse desde la CPU. Estos registros ocupan las direcciones hexadecimales FFF0-FFF3. Lo mismo para el registro de máscara. Su dirección es la FFF416. Solución: La solución de este problema se puede plantear en dos etapas: La primera consiste en diseñar el mecanismo de petición y reconocimiento de interrupciones. La segunda consiste en diseñar el mecanismo de lectura/escritura de los vectores y del registro de máscara. En cualquier caso, el diagrama simplificado del controlador solicitado podría ser el mostrado en la figura. Este diagrama incluye los registros (de vectores y máscara), las señales de petición y reconocimiento de interrupción, el bus de datos, el bus de direcciones y la señal de lectura/escritura (1 r lectura, 0 r escritura).

Esquema del controlador de interrupciones.

En primer lugar procedemos con la resolución de peticiones y reconocimiento de interrupciones. En cuanto a la petición de interrupciones, y siguiendo el esquema de problemas anteriores, podemos hacer uso de un codificador de prioridad que junto con el registro de máscara filtre la línea que solicita la interrupción. Es importante destacar que debido a que el registro de máscara forma parte del controlador no es necesario hacer uso de los buses para solicitar la información del mismo. Por otro lado, podemos utilizar un mecanismo de prioridad ascendente (INTR0 a INTR1 a INTR2 a INTR3), con lo que el diseño podría ser el siguiente:


501

Diseño de petición de interrupciones.

Por otro lado, el reconocimiento de interrupción por los distintos niveles (INTAi) puede realizarse de múltiples formas. Una de ellas es utilizar un decodificador 2 a 4 con una señal de capacitación (E). Esta señal estará directamente conectada a INTA, de forma que el decodificador se pondrá en funcionamiento siempre y cuando la CPU reconozca la petición. Cada salida del decodificador se corresponde con una línea de reconocimiento de interrupción (INTAi). El diseño final se muestra en la siguiente figura:

Diseño de solicitud y reconocimiento de interrupciones.

En cuanto a la lectura y escritura de los registros del controlador, el procedimiento consiste en conectar los cuatro registros al bus de datos con dos caminos, uno para lectura (del registro al bus de datos) y otro para escritura (del bus de datos al registro). Un posible esquema podría ser el de la figura siguiente.

502


Lectura y escritura de los registros. Señales de control.

Por otro lado, ¿cuál es la lógica de las señales de control MaskRead, MaskWrite, ViRead y ViWrite? Con respecto al registro de máscara parece claro que solamente una instrucción del repertorio podrá hacer las funciones de lectura o escritura. En cuanto a los vectores Vi, la operación de escritura podrá ser realizada por instrucciones del repertorio, pero la operación de lectura podrá hacerse cuando: (a) una instrucción lo requiera o (b) se reconozca una interrupción (INTAi % 1), es decir: ViRead % ViRead’ ! INTAi donde ViRead’ denota la lectura del vector por parte de una instrucción. Finalmente, la activación de las señales de control anteriores debe ir acompañada por las señales de control de la CPU junto con la dirección correcta en el bus de direcciones. En la figura se ilustra el procedimiento de activación de dichas señales.

Diseño de activación de las señales de control para lectura (izquierda) y escritura (derecha).


503

Como se puede apreciar en la figura, se activarán las señales de control en función de la señal R/W, (1 lectura, 0 escritura) y de que la dirección suministrada por la CPU (A15..A0) sea la correcta (FFF016 a FFF416). Finalmente, para resumir, en la siguiente figura se muestra el diseño completo.

Esquema del diseño completo.

504


PROBLEMA 10 Un procesador dispone de ocho líneas de interrupción (numeradas del 0 al 7) y una política en la que las interrupciones con un número bajo tienen mayor prioridad sobre aquellas de número más alto. El procesador comienza sin interrupciones pendientes y se produce la siguiente secuencia de interrupciones: 4, 7, 1, 3, 0, 5, 6, 4, 2, 1. Suponga que la gestión de una interrupción tarda el tiempo suficiente para que se produzcan dos nuevas interrupciones y que las interrupciones no se pueden interrumpir entre sí. Calcule el orden en que se gestionan las interrupciones. Solución: Según el enunciado «la gestión de una interrupción tarda el tiempo suficiente para que se produzcan dos nuevas interrupciones». Esto significa que mientras se atiende la primera interrupción (4) se pueden producir hasta dos nuevas interrupciones (7, 1). Después de (4) se atenderá la de mayor prioridad (1), lo que dará tiempo a dos nuevas interrupciones (3, 0). Como se está procesando la interrupción 1, las interrupciones pendientes hasta ahora son (7, 3, 0). Una forma de resolver este problema es crear una lista de interrupciones pendientes. Cada vez que el procesador queda libre se gestiona la interrupción pendiente de mayor prioridad (que es la de menor número), eliminándola de la lista. En la tabla siguiente se muestra el orden en que van siendo atendidas las interrupciones, así como las interrupciones solicitadas y pendientes en cada momento. Interrupción atendida

Interrupciones solicitadas

Interrupciones pendientes

4

7, 1

7, 1

1

3, 0

7, 3, 0

0

5, 6

7, 3, 5, 6

3

4, 2

7, 5, 6, 4, 2

2

1

7, 5, 6, 4, 1

La interrupción 4 es la que se gestiona en primer lugar, ya que es la primera en llegar. Cuando el procesador termina de gestionar la interrupción 4, están pendientes las interrupciones 7 y 1, por lo que se gestiona la interrupción 1. Repitiendo dicho proceso, se obtiene el orden de gestión de las interrupciones siguientes: 4, 1, 0, 3, 2. Después de atender la interrupción 2 quedan cinco interrupciones pendientes (7, 5, 6, 4, 1), que se atenderán según su prioridad. Es decir, en el orden: 1, 4, 5, 6, 7. Por lo tanto, el orden en el que se gestionan las interrupciones es el siguiente: 4, 1, 0, 3, 2, 1, 4, 5, 6, 7. PROBLEMA 11 Un controlador de DMA está transmitiendo, mediante robo de ciclos, caracteres a memoria desde un periférico a una velocidad de 19.200 bps (bits/s). Por su parte la CPU realiza la búsqueda de las instrucciones con una velocidad de 2 millones de instrucciones por segun-


505

do (2 MIPS). ¿En qué porcentaje se reduce la velocidad del procesador debido al controlador de DMA? Suponer una longitud de palabra de M bits y que la CPU emplea, en promedio, N ciclos para ejecutar una instrucción. Solución: La siguiente figura muestra un esquema de funcionamiento de DMA con robo de ciclo. Cuando el DMA toma el control retiene el bus durante un ciclo, transmite la palabra y libera el bus.

DMA con robo de ciclo.

El controlador de DMA está transmitiendo a una velocidad de 19.200 bps. Como la longitud de palabra es de M bits, el número de palabras por segundo que se transmiten es: 19.200 bps 19.200 palabras % bits M segundo M palabra Como en cada ciclo el DMA transmite una palabra completa se produce igual número de robo de ciclos: 19.200 ciclos Ciclos robados por segundo % M segundo ¿Cuántas instrucciones deja de ejecutar la CPU cada segundo? Podemos calcularlo teniendo en cuenta que la CPU emplea una media de N ciclos en ejecutar una instrucción: 19.200 ciclos M segundo % Instrucciones que deja de ejecutar la CPU por segundo % ciclos N instrucción %

19.200 instrucciones M # N segundo

Ahora bien, la CPU cuando no dispone de DMA ejecuta 2 # 106 instrucciones por segundo, por lo tanto, la fracción de instrucciones no ejecutadas es (en porcentaje):

506


19.200 instrucciones M # N segundo % instrucciones no ejecutadas por segundo % # 100 % instrucciones 6 2 # 10 segundo %

0,96 1.920.000 % 6 %% M#N M # N # 2 # 10

Por lo tanto, el porcentaje de reducción nunca será mayor del 0,96%. PROBLEMA 12 Un computador dispone de una unidad de disco con una velocidad de lectura de 221 palabras por segundo que para transferir su contenido a la memoria principal utiliza DMA por ráfagas. El controlador de DMA tarda 4 ciclos de reloj en transmitir cada palabra. Cuando la CPU dispone en exclusiva del bus las instrucciones emplean, en promedio, 8 ciclos de reloj en ser ejecutadas. Si la frecuencia de reloj del computador son 500 # 106 ciclos/s, en una operación de lectura del disco ¿Cuántas instrucciones por segundo dejan de ser ejecutadas por la CPU? Solución: En un segundo la unidad de disco lee 221 palabras. Estas palabras necesitan 221 palabras # 4 ciclos/palabra % 223 ciclos para transferirse a memoria cada segundo. Estos 223 ciclos suponen 223/8 % 220 instrucciones que la CPU no ejecuta en un segundo. Esto supone un porcentaje de uso de la CPU de aproximadamente el 0,02%. PROBLEMA 13 Un controlador de DMA está transmitiendo palabras a memoria mediante la estrategia transparente. Cuando la CPU dispone en exclusiva del bus las instrucciones emplean, en promedio, 4 ciclos de reloj en ser ejecutadas, aunque en 2 de ellos no se requiere el acceso al bus. El controlador de DMA tarda 1 ciclo de reloj en transmitir una palabra. Si la frecuencia de reloj del computador es de 106 ciclos/s, ¿cuánto tiempo tardará el controlador de DMA en mover un bloque de datos compuesto por 106 palabras? Solución: El controlador de DMA aprovecha los dos ciclos de reloj en los que la CPU no utiliza el bus cuando ejecuta una instrucción, para transmitir una palabra. Por tanto, en los 4 ciclos de reloj que tarda la CPU en ejecutar una instrucción, el controlador de DMA transmite 2 palabras. La velocidad de transferencia resultante, si el reloj del computador tiene una frecuencia de 106 ciclos/s, es de: 106

ciclos palabras 2 palabras # % 0,5 # 106 segundo 4 ciclo segundo


507

Con esta velocidad de transferencia, para mover un bloque de 106 palabras el controlador de DMA tardará: 106 palabras %2 s palabras 6 0,5 # 10 s PROBLEMA 14 Un computador funciona a una frecuencia de 10 MHz (107 ciclos/s) con un CPI % 4 ciclos y cada operación de lectura o escritura de memoria tarda un ciclo. Determinar la máxima velocidad de transferencia de datos, en palabras por segundo, para los cuatro casos siguientes: a) E/S controlada por programa que utiliza 3 instrucciones en transferir cada palabra. b) DMA con transferencia por ráfagas. c)

DMA con transferencia por robo de ciclo.

d) DMA con transferencia transparente suponiendo que en cada instrucción, en promedio, hay 2 ciclos en los cuales la CPU no utiliza el bus. Solución: a) E/S programada N.o de ciclos para transferir una palabra % 3 intrucciones/palabra # 4 ciclos/instrucción % 12 ciclos/palabra. Velocidad del computador 107 ciclos/segundo. Velocidad de transferencia máxima % 107 ciclos/segundo / 12 ciclos/palabra % % 8,3 # 105 palabras/segundo. b) DMA por ráfagas Esta figura muestra un esquema del procedimiento de transferencia por ráfagas.

Esquema de transferencia por ráfagas.

Velocidad de transferencia máxima % 107 ciclos/segundo / 1 ciclos/palabra % 107 palabras/segundo. c)

DMA por robo de ciclo A continuación se muestra un esquema de transferencia por robo de ciclo.

Esquema de transferencia por robo de ciclo.

Velocidad de transferencia máxima % 107 ciclos/segundo / 5 ciclos/palabra % 2 # 106 palabras/segundo.

508


d) DMA transparente Con esta técnica, el DMA aprovecha los ciclos de la instrucción que no utiliza el bus. La siguiente figura presenta un esquema de esta transferencia.

Esquema de transferencia de DMA transparente.

Velocidad de transferencia máxima % 107 ciclos/segundo / 2 ciclos/palabra % 5 # 106 palabras/segundo. PROBLEMA 15 Un periférico con una velocidad de transferencia de 1,5 # 106 bytes/segundo se conecta mediante un DMA a un procesador que tarda una media de 200 nanosegundos en ejecutar una instrucción. El DMA requiere 10 instrucciones de inicialización y la transferencia de un byte mantiene ocupados los buses durante 100 nanosegundos. Se quieren transferir 500 bytes. Calcular en DMA con transferencia por robo de ciclo: a) El tiempo que se le roba al procesador a la transferencia de los 500 bytes. b) El número de instrucciones que podría dedicar el procesador a otro proceso mientras se realiza la transferencia del bloque de datos. Solución: a) El tiempo que dedica el procesador a la transferencia será el tiempo de inicialización del DMA más el tiempo propio de transferencia del DMA. El tiempo de inicialización del DMA es: tini. % 10 instr. # 200

ns % 2.000 ns % 2 ]s instr.

El tiempo robado por el DMA en la transferencia es: trobo % 500 B # 100

ns % 50.000 ns % 50 ]s B

El tiempo total robado al procesador será: T % tini. ! trobo % 52 ]s


509

b) El tiempo que tarda en realizarse la transferencia del bloque de datos una vez que se ha inicializado el DMA es: ttransf. % 500 B #

1 B % 3,33 # 10.4 s % 333 ]s 6 1,5 # 10 s

Durante este tiempo, 50 ]s se pierden en robos de ciclo del DMA, luego el tiempo que podrá dedicar la CPU a la ejecución de otro proceso será de 333 ]s.50 ]s%283 ]s. En 283 ]s, la CPU puede ejecutar el siguiente número de instrucciones: Ninstr. % 283 ]s #

1 ns % 1.415 instr. 200 instr.

PROBLEMA 16 Sea un computador capaz de ejecutar 10 MIPS (107 instrucciones por segundo). Se desea conectar al computador únicamente un periférico con una velocidad de transferencia de 20.000 bytes/segundo y sobre el que se realizan operaciones de lectura de bloques de 1.024 bytes. Se pretende ver el comportamiento de la pareja computador-periférico ante las diferentes técnicas de entrada-salida (programada, mediante interrupciones y por DMA). Se sabe que: La rutina de transferencia de E/S programada consta de 10 instrucciones. La rutina de tratamiento de interrupción en la E/S mediante interrupciones consta de 20 instrucciones. La rutina de inicialización del DMA consta de 8 instrucciones. Y en cada operación de escritura de un dato en memoria el controlador ocupa los buses durante 500 ns. Se pide indicar el número de instrucciones de otros procesos que puede realizar el computador durante cada uno de los siguientes tipos de E/S: a) E/S programada. b) E/S mediante interrupciones. c)

E/S mediante DMA.

Solución: El periférico suministra 20.000 bytes/segundo, es decir, enviará un byte cada 50 ]s. Como los bloques son de 1.024 bytes, una operación de E/S durará: 50 ]s # 1.024 B % 51.200 ]s B La CPU en ese tiempo es capaz de ejecutar: Instrucciones ejecutadas por la CPU en 51.200 ]s % 107

instr. # 51.200 ]s % 512.000 instr. s

510


a) Al ser entrada-salida programada, la CPU está plenamente dedicada a ejecutar las instrucciones de la rutina de entrada-salida y a realizar encuesta, con lo que no es capaz de ejecutar ninguna instrucción de otro proceso. b) La rutina de interrupción consta de 20 instrucciones. Esta rutina se ejecuta cada vez que se transfiere un byte. Número de ejecuciones de la RTI %

1.024 B % 1.024 ejecuciones B 1 ejecución

Lo que supone un total de: Número de instrucciones de E/S % 1.024 ejecuciones # 20

instrucciones % ejecución

% 20.480 instrucciones Esto supone que la CPU podría dedicar tiempo a otros procesos: 512.000 instrucciones . 20.480 instrucciones % 491.520 instrucciones c) La CPU dedicará el tiempo necesario para poder programar el controlador de DMA. El DMA emplea robo de ciclo, con lo que el periférico ocupará los buses 500 ns/B. Con lo que para leer 1.024 B, tardará: 500 ns/B # 1.024 B % 512.000 ns % 512 ]s Dado que la rutina de inicialización del controlador del DMA consta de 8 instrucciones, podemos aproximar el cálculo a los 512 ]s que se corresponden con los robos de ciclo. En ese tiempo, la CPU habrá ejecutado 5.120 instrucciones, que se corresponderán con el hecho de que durante el robo de ciclo por cada dato, la CPU no puede acceder a los buses. La CPU podrá ejecutar: 512.000 instrucciones . 5.120 instrucciones % 506.880 instrucciones 506.880 instrucciones correspondientes a otros procesos. Resumiendo: Instrucciones totales

Instrucciones para otros procesos

E/S programada

512.000

0

E/S mediante interrupciones

20.480

491.520

E/S mediante DMA

5.120

506.880

Tipo de E/S


511

PROBLEMA 17 Supongamos dos sistemas de E/S diseñados para realizar transacciones: El sistema A soporta 1.500 operaciones de E/S por segundo. El sistema B soporta 1.000 operaciones de E/S por segundo. Ambos sistemas usan el mismo procesador que puede ejecutar 500 millones de instrucciones por segundo. Cada transacción requiere 5 operaciones de E/S y cada operación de E/S requiere 10.000 instrucciones. Asumiendo que las transacciones se pueden ajustar al máximo e ignorando tiempos de respuesta, ¿cuál es el máximo número de transacciones por segundo que cada sistema puede soportar? Solución: La solución es sencilla siempre y cuando apliquemos correctamente las conversiones, para el procesador tenemos: instr. 1 operación transac. 1 transac. # # 500 # 106 % 50.000 s segundo 5 operaciones 10.000 instr. Sin embargo cada sistema introducirá un cuello de botella a esta capacidad. El sistema A admite 1.500 operaciones de E/S por segundo, esto implica: 1.500

1 transac. transac. operación # % 300 5 operaciones segundo segundo

Mientras que para el sistema B: 1.000

1 transac. transac. operación # % 200 5 operaciones segundo segundo

PROBLEMA 18 Considere un computador portátil cuya batería almacena hasta 100.000 julios. Queremos transferir archivos de 400 MB desde este computador a otro mediante una tarjeta de conexión inalámbrica de 5 Mb/s. La tarjeta consume 5 W mientras está transmitiendo. El disco duro consume 6 W cuando gira y 1 W cuando no gira. La potencia consumida por el portátil aparte del disco duro y la tarjeta de red inalámbrica es de 32 W. Suponga que en promedio el sistema emplea 10 s en buscar un fichero, que la tasa de transferencia del disco duro es de 50 MB/s, que el retardo al inicio de una transferencia es de 20 ms, y que el resto del tiempo el disco no gira. a) ¿Cuántos archivos completos podemos transferir antes de que se agote la batería del portátil? b) ¿Cuánta energía se requerirá para enviar 100 ficheros? Solución: Potencia consumida por el portátil mientras busca un fichero: 32 W ! 6 W % 38 W. Potencia consumida por el portátil mientras transfiere un fichero: 33 W ! 5 W % 38 W. Tiempo empleado en buscar un fichero: 10 s.

512


Tiempo empleado en enviar un fichero: 400 MB / 50 MB/s % 8 s. Retardo inicial: 20 ms. Por lo tanto el tiempo total en enviar un fichero es % 10 s ! 8 s ! 0,02 s % 18,02 s. Y la energía consumida en enviar un fichero es % 18,02 s # 38 W % 684,76 J/fichero. a) El número de ficheros a enviar será la energía total del portátil entre la energía necesaria para enviar un fichero:

C

D

100.000 J J % 146 ficheros 684,76 fichero

b) La energía necesaria para enviar 600 archivos será: 100 ficheros # 684,76

J % 6.847,6 J fichero

PROBLEMA 19 Un formato típico de los disquetes de 3,5 pulgadas tiene 2 superficies, 80 cilindros, 18 sectores por pista y 512 bytes por sector. a) Calcular su capacidad total. b) Suponiendo que el disco gira a 360 r.p.m., ¿cuál será su velocidad de transferencia? Solución: a) 2 superficies # 80 pistas/superficie # 18 sectores/pista # 512 B/sector%10.474,560 B% %1,40 MB. b) La velocidad de transferencia es: b Vt % % P # f tt donde b representa el número de bytes que se desean transferir, tt es el tiempo que se emplea en la transferencia, P el número de bytes que hay en una pista y f la velocidad de rotación en revoluciones por segundo. Así, Vt % 512 # 18 #

360 B % 55.296 60 s

PROBLEMA 20 Calcular el tiempo medio de lectura o escritura de un sector de 512 bytes en un disco duro que gira a 4.500 r.p.m. suponiendo que: El tiempo medio de posicionado es de 20 ms. La velocidad de transferencia es de 2 MB/s. La sobrecarga debida al controlador es de 2 ms. No existe tiempo de espera porque el disco está desocupado.


513

Solución: El acceso medio de lectura es igual al tiempo medio de posicionado ! retardo medio de rotación (se corresponde con la rotación de medio disco) ! tiempo de transferencia ! sobrecarga del controlador. El retardo medio de rotación, dato no proporcionado en el enunciado es: 0,5 rotación / 4.500 r.p.m. % 0,5/(4.500 r.p.m. / 60 s/min) % 6,7 ms Utilizando el tiempo medio de posicionamiento la respuesta es: 20 ms ! 6,7 ms !

0,5 KB ! 2 ms % 20 ! 6,7 ! 0,2 ! 2 % 28,8 ms MB 2,0 s

PROBLEMA 21 Un disco magnético tiene dos superficies. El área de almacenamiento en cada superficie tiene un radio interior de 1 cm y un radio exterior de 5 cm. Si bien el tamaño de cada pista es diferente, cada una de ellas almacena el mismo número de bits. La densidad de almacenamiento máximo que soporta este disco es de 10.000 bits/cm. El espaciado entre puntos correspondientes en pistas adyacentes es de 0,1 mm, lo que incluye además el espaciado entre pistas. Supóngase despreciable el espaciado entre sectores. Se pide: a) ¿Cuál es el máximo número de bits que se puede almacenar en el disco? b) Suponiendo que el disco tiene la capacidad de almacenamiento anteriormente calculada, ¿cuál es la velocidad de transferencia de datos desde el disco a la cabeza de lectura/escritura en bits/s si el disco gira con una velocidad de rotación de 3.600 r.p.m.? Para realizar este cálculo suponga que el disco no tiene entrelazado y que en un determinado instante sólo se puede acceder a una de las superficies del disco. Solución: a) Desde el punto de vista del almacenamiento de la información, se considera que cada superficie del disco está constituida por un conjunto de pistas a lo largo de las cuales se va almacenando la información con una densidad lineal de almacenamiento de 10.000 bits/cm.

Diagrama de superficies, sectores y pistas.

Cada pista del disco magnético se divide en sectores. Como el enunciado indica explícitamente que se supone despreciable el espaciado que hay entre los sectores, no hay

514


que considerar en lo que sigue la subdivisión de las pistas en sectores, y por lo tanto, la información se distribuye regularmente a lo largo de cada pista con la densidad lineal dada.

Anchura de la zona de almacenamiento.

Los pasos a seguir para el cálculo de la capacidad son los siguientes: 1.

Número de pistas que contiene cada superficie:

Para calcular este número se dispone de la anchura de la zona de almacenamiento, que es: r2 . r1 % 4

cm mm % 40 superficie superficie

y del espaciado entre pistas adyacentes, que es 0,1 mm (lo que equivale a 10 pistas/mm). El número de pistas de almacenamiento es: 40

mm pistas pistas # 10 % 400 superficie mm superficie

2. El enunciado señala que cada pista contiene el mismo número de bits. La pista más interna tiene la menor capacidad de almacenamiento, así pues todas las pistas no almacenarán más datos que la pista más interna. El número de bits que almacena dicha pista es: cm bits bits bits #2#n#1 % 2.000 # n % 62.832 10.000 pista pista pista cm 3.

El almacenamiento por superficie es:

62.832 4.

bits bits bits pistas # 400 % 8 # n # 106 % 25,13 # 106 superficie superficie pista superficie

El almacenamiento en el disco es: 2

bits bits superficies Mb # 25,13 # 106 % 16 # n # 106 % 50,26 superficie disco disco disco


515

b) En el segundo apartado del problema, se pregunta cuál es la velocidad de transferencia de datos desde el disco a la cabeza de lectura/escritura en bits/s. El disco gira con una velocidad de rotación de 3.600 r.p.m., que es equivalente a 60 r.p.s. La velocidad de transferencia es igual al número de bits que hay en una pista (P % 62832 bits / pista) multiplicado por la velocidad de rotación en r.p.s. ( f % 60 r.p.s.). VT % P # f % 20.000 # n # 60 % 62.832 # 60 % 3,77

Mb s

13.8 Problemas propuestos PROBLEMA 1 Consideremos un programa que requería de 0,1 segundos para su ejecución sobre un cierto computador de hace 8 años, de los cuales el 60% se corresponde a tiempo de CPU y el 40% restante se corresponde con operaciones de entrada y salida sobre una cierta interfaz. Supongamos que dicho programa se ejecuta sobre un nuevo computador de este año y supóngase asimismo la siguiente evolución desde hace 10 años: El rendimiento de la CPU se multiplica por dos cada dos años, es decir, se reduce a la mitad el tiempo de CPU. El rendimiento de la interfaz de entrada y salida se multiplica por dos cada cuatro años, es decir, el tiempo necesario para mover la misma información entre la interfaz y la memoria requiere la mitad del tiempo. ¿Cuál pasa a ser el tiempo de ejecución del programa en el nuevo computador de este año? PROBLEMA 2 Calcula la interferencia con el procesador de un periférico que recibe bloques de datos de 64 bytes con una velocidad de transferencia de 1 MB/s. La frecuencia del procesador es de 100 MHz, y el módulo de E/S de este periférico lo interrumpe cada vez que recibe un bloque, consumiendo la rutina de tratamiento de la interrupción de este periférico 400 ciclos de procesador. PROBLEMA 3 Supongamos un disco duro que utiliza el modo de transferencia con las siguientes características: Se transfiere una palabra de 16 bits entre el disco y la interfaz en cada ciclo de reloj, de periodo 120 ns. Cada vez que se transfiere un bloque de 512 bytes (un sector) entre el disco y la interfaz, ésta solicita una interrupción. El movimiento de un bloque de datos entre la interfaz y la memoria lo lleva a cabo la CPU durante la rutina de tratamiento de la interrupción. Esta rutina de servicio tiene un coste de 4.000 ciclos de reloj en una CPU de frecuencia 1 GHz.

516


¿Cuál es la máxima velocidad de transferencia? ¿Cuál es el porcentaje del tiempo de procesador consumido cuando el disco transfiere a la máxima velocidad permitida? Para mejorar la velocidad de transferencia y disminuir a la vez el porcentaje de ocupación de la CPU durante las transferencias, se dota a este sistema de un controlador DMA para transferir directamente datos entre la interfaz de disco y la memoria, a una velocidad máxima de 100 Mbytes/s. En este caso, la interrupción simplemente avisa a la CPU del final de la transferencia, por lo que la RTI tiene poco trabajo que hacer. Supondremos que la RTI consume sólo 40 ciclos de reloj de la CPU en esta situación. ¿Qué porcentaje del tiempo de procesador se consume empleando el modo DMA? PROBLEMA 4 Supongamos CPUs con bus de direcciones de ancho idéntico. Si una de ellas emplea E/S aislada, y la otra localizada en memoria, ¿cuál podrá acceder a una mayor cantidad de memoria y por qué? PROBLEMA 5 Sea una CPU con un único nivel de interrupción por una línea INTR, una señal de reconocimiento INTA y una entrada AVEC que le indica el tipo de la interrupción (AVEC % 1 si es autovectorizada y AVEC % 0 si es con vector de usuario). La señal INTA sólo se activa si la interrupción es de usuario (AVEC % 0). a) Diseñar la lógica de control de interrupciones necesaria para dotar a un computador basado en dicha CPU de 8 niveles de interrupción, 4 autovectorizadas y 4 vectorizadas o de usuario. Asignar las prioridades de modo que el nivel 3 sea el más prioritario en cada caso, y las autovectorizadas más prioritarias que las de usuario. b) En el caso de interrupciones autovectorizadas diseñar la lógica necesaria para generar un autovector distinto por cada nivel. c)

En el caso de interrupciones de usuario diseñar la lógica para la resolución de prioridades entre los dispositivos de un mismo nivel y para el envío del vector almacenado en el dispositivo. Suponer el flag de petición de interrupción almacenado en un biestable, y el número de vector en un registro de 8 bits.

PROBLEMA 6 El sistema de E/S de un computador puede ejecutar transferencias DMA tanto en modo robo de ciclo como en modo ráfaga. La latencia de atención a peticiones DMA es de 9 ciclos, el número de instrucciones de una rutina de programación de una transferencia DMA es de 437 y el CPI medio es de 5 ciclos. El tiempo de transferencia de un bloque DMA de 16 bytes es de 28 ciclos. Determinar el tiempo total en ciclos invertido en realizar una transferencia de 512 bytes en ambos modos.


517

PROBLEMA 7 Calcula la interferencia con un procesador a 2 GHz de un periférico que recibe bloques de datos de 2 KB con una velocidad de transferencia de 512 MB/s, en los siguientes casos: a) Se utiliza un DMA donde se consumen 900 ciclos en la programación del DMA y 100 en la interrupción final. b) Se utiliza E/S con interrupciones y el módulo de E/S de este periférico interrumpe al procesador cada vez que recibe una palabra (32 bits/palabra). La rutina para el tratamiento de la interrupción de este periférico consume 40 ciclos del procesador. PROBLEMA 8 Un procesador que opera a 200 MHz con un CPI % 4 dispone de un sistema de interrupciones con un tiempo de reconocimiento de interrupción de 100 ns. Se conecta a un disco magnético con 128 sectores/pista y 1.024 bytes/sector a través del sistema de interrupciones. En cada interrupción se transmiten 8 bytes utilizando una rutina de tratamiento de interrupciones que ejecuta 20 instrucciones. Determinar: a) Capacidad de entrada de datos (ancho de banda) máxima en bytes/segundo a través del sistema de interrupciones. b) Velocidad de rotación máxima a la que podrá operar el disco en r.p.m. (revoluciones por minuto). c)

Si el disco se conecta a través de DMA operando por robo de ciclo y cada vez que se le concede el bus transmite 8 bytes, calcular el tiempo que el DMA roba a la CPU durante la lectura de un sector.

d) Porcentaje de tiempo que la CPU dedica a la E/S durante la operación del DMA si el disco opera a la velocidad determinada en el apartado b). PROBLEMA 9 Considere una CPU que ejecuta 300 millones de instrucciones por segundo y que emplea una media de 50.000 instrucciones de sistema operativo en cada operación de entrada/salida, junto con un bus de memoria backplane con una velocidad de transferencia de 100 MB/s. Se dispone de controladores SCSI-2 con velocidad de transferencia de 20 MB/s que permiten la conexión de hasta siete discos y de unidades de disco con ancho de banda de lectura/escritura de 5 MB/s y un tiempo medio de posicionado más latencia de rotación de 10 ms. Suponiendo que la carga de trabajo consiste en lecturas de bloques de 64 KB (cada bloque se encuentra secuencialmente en una pista) y que un programa de usuario necesita 100.000 instrucciones por cada operación de E/S, encuentre la máxima velocidad de E/S que puede mantenerse y el número de discos y controladores SCSI necesarios. Suponga que las lecturas siempre se pueden realizar en un disco inactivo, si es que existe (es decir, ignore los conflictos en el disco). PROBLEMA 10 El CD almacena bloques de 2.352 bytes cada uno, los cuales se reproducen a un ritmo de 75 bloques por segundo cuando almacena audio. Cuando un CD almacena datos, de los

518


2.352 bytes por bloque sólo 2.048 almacenan efectivamente datos mientras que los restantes bytes almacenan códigos de detección y corrección de errores. Una situación intermedia ocurre cuando el CD almacena vídeo en formato VCD o SVCD, pues en este caso, de los 2.352 bytes totales se emplean sólo 2.324 para almacenar datos. ¿Qué capacidad en Mbytes tiene un CD etiquetado con 74 minutos cuando almacena audio? ¿Qué capacidad en Mbytes tiene un CD etiquetado con 74 minutos cuando almacena datos? ¿Qué capacidad en Mbytes tiene un CD etiquetado con 74 minutos cuando almacena video SVCD?

Las distintas unidades funcionales de un computador necesitan comunicarse. Deben existir, por lo tanto, líneas para interconectar estos módulos.

Figura 14.1. Líneas definidas para la interconexión de módulos.

Los tipos de transferencias a las que debe dar cobertura la estructura de interconexión son: Procesador T Memoria. Procesador T E/S. Memoria T E/S (DMA). Un bus es un canal de comunicación compartido que utiliza un conjunto de líneas para conectar múltiples subsistemas. Cada cable o línea transmite un único bit de información en un determinado momento. Sus ventajas incluyen la versatilidad y el bajo coste. Una gran desventaja es la aparición de un cuello de botella, limitando la productividad máxima del sistema. A la hora de diseñar un sistema de buses, el reto consiste en cubrir la demanda de comunicación del sistema y permitir la conexión de un gran número de dispositivos de E/S. Las características deseables de un bus son la heterogeneidad, escalabilidad, baja latencia y alto ancho de banda.

520


El principal problema en el diseño de un bus es que la velocidad máxima (y por tanto el rendimiento) está fuertemente limitada por cuestiones físicas, tales como la longitud del bus, el número de dispositivos conectados. También debe dar soporte a una gran variedad de dispositivos con muy distintas latencias y anchos de banda.

14.1 Estructura del bus Las líneas que componen un bus se pueden clasificar en tres grupos funcionales: Las líneas de datos del bus proporcionan el camino para transmitir datos entre los módulos del sistema. El número de líneas del bus de datos determina el número máximo de bits que es posible transmitir al mismo tiempo. Las líneas de dirección se utilizan para designar (direccionar) la fuente o el destino de los datos situados en el bus de datos. La anchura del bus de direcciones determina la cantidad máxima de memoria (y de dispositivos de E/S) direccionable en el sistema. Las líneas de control se emplean para gestionar el acceso y el uso de las líneas de datos y dirección, señalizando peticiones y reconocimientos e indicando qué tipo de información pasa por las líneas de datos.

Figura 14.2.

Esquema de bus.

La clasificación según las características eléctricas es: Unidireccionales con un transmisor y múltiples receptores. Unidireccionales con múltiples transmisores y un único receptor. Bidireccionales. Algunas líneas de control típicas son: escritura en memoria (Memory Write), lectura de memoria (Memory Read), escritura de E/S (I/O Write), lectura de E/S (I/O Read), transferencia reconocida (Transfer ACK), petición de bus (Bus Request), cesión de bus (Bus Grant), petición de interrupción (Interrupt Request), interrupción reconocida (Interrupt ACK), reloj (Clock), e inicio (Reset).

14.2 Uso básico del bus Cuando un módulo necesita enviar un dato a otro módulo, se deben realizar las siguientes acciones:

Capítulo 14 Buses

521

1. Obtener el uso del bus. 2. Transferir el dato a través del bus. Cuando un módulo necesita pedir un dato a otro módulo, se deben realizar las siguientes acciones: 1. Obtener el uso del bus. 2. Transferir la petición al otro módulo mediante las líneas de control y dirección apropiadas. 3. Esperar a que el segundo módulo envíe el dato.

14.3 Clases de buses y jerarquías Aunque existen muchas clases y jerarquías de buses, generalmente podemos encontrar: Bus local y bus de sistema: Son rápidos y de corta longitud, suelen ser buses propietarios y por tanto diseñados para dispositivos específicos y optimizados para la arquitectura a la que van destinados. Bus de expansión o de E/S: Son buses más largos y por tanto más lentos, suelen tener especificaciones abiertas y son accesibles por el usuario. En ellos se puede conectar un número indeterminado de dispositivos de distintas prestaciones.

Figura 14.3. Jerarquía de buses.

522


14.4 Diseño del bus Al diseñar un bus, hay que tener en cuenta multitud de parámetros de configuración. A continuación, se enumeran algunos de estos parámetros: Tipo de bus Dedicado Compartido Número de maestros del bus Uno Varios Método de arbitraje Centralizado Distribuido

Anchura del bus Temporización Dirección Síncrono Datos Asíncrono Tipo de transferencia de datos Lectura Escritura Lectura-modificación-escritura Lectura después de escritura Bloque Transacción partida: Se dividen los eventos del bus en peticiones y respuestas. Otro maestro puede usar el bus.

A continuación describimos algunos de estos parámetros de diseño:

14.4.1 Temporización Bus síncrono: Entre sus líneas de control se incluye una señal de reloj. El protocolo para la comunicación es fijo y está gobernado por la señal de reloj. Se asume que los envíos llegan correctamente. Ventajas: Puede funcionar a gran velocidad y se puede implementar con un sistema secuencial sencillo. Inconvenientes: No es adecuado para mezclar dispositivos con grandes diferencias de velocidad. Su diseño tiene que ser muy cuidadoso ya que puede presentar problema el sesgo del reloj (clock skew). Los buses de memoria suelen ser síncronos.

Figura 14.4. Lectura síncrona.

Bus asíncrono: Sin reloj. Las transmisiones de datos se coordinan con un protocolo de handshaking entre emisor y receptor: un evento origina el siguiente, y así sucesivamente. Ventajas: Permite la conexión de dispositivos de un amplio rango de velocidades diferentes. Escalan mejor tanto con el número de dispositivos como con los cambios tecnológicos en los mismos. No hay problemas de sesgo de reloj, por lo que permite distancias más largas.

Capítulo 14 Buses

523

Inconvenientes: Es más lento, debido a la sobrecarga introducida para sincronizar a emisor y receptor. Puede necesitar un cierto número de líneas de control adicionales para implementar el protocolo. Es más difícil predecir el tiempo que va a llevar una determinada transacción. Los buses de E/S son habitualmente asíncronos. A continuación ilustramos un ejemplo sencillo acerca de cómo trabajan los buses asíncronos. Consideremos un dispositivo que solicita un dato del sistema de memoria. Consideramos tres líneas de control: (1) ReadReq utilizada para realizar una petición de lectura, (2) DataRdy usada para indicar que el dato está listo en el bus de datos, y (3) Ack usada por la otra parte para indicar la recepción de la señal ReadReq o DataRdy.

Figura 14.5. Protocolo asíncrono «handshaking». Las líneas de mayor grosor son aquellas asertadas por el dispositivo (el procesador, por ejemplo), el resto son las controladas por la memoria.

De acuerdo con la figura anterior la secuencia de pasos a seguir es la siguiente: 0.

El protocolo comienza con el maestro (el procesador, por ejemplo) poniendo una dirección de memoria en el bus de datos y activando la señal de petición de lectura (ReadReq).

1.

El esclavo (la memoria, por ejemplo) ve la petición y coge la dirección de memoria del bus de datos, activando la señal de aceptación (ACK).

2.

El maestro ve activa la señal de ACK y libera el bus de datos y desactiva la señal de petición de lectura, que sirve de aviso al esclavo.

3.

El esclavo ve la desactivación de la señal de petición y contesta asimismo con la desactivación de la señal de ACK.

4.

Cuando el esclavo tiene listo el dato a leer lo pone en el bus y activa la señal que indica que el dato está listo (DataReady).

5.

El maestro ve la señal DataReady, con lo que sabe que el dato está listo en el bus y realiza su lectura. Cuando completa la operación activa la señal de ACK.

6.

El esclavo ve la señal de ACK, lo que le dice que el maestro ya tiene el dato leído, y desactiva la señal DataReady y libera el bus de datos.

7.

Por último, el maestro responde a la desactivación de DataReady con la bajada de su señal de ACK, lo que da por concluida la transmisión.

524


14.4.2 Tipos de transferencia de datos La Figura 14.6 muestra esquemáticamente los distintos tipos de transferencias de datos que generalmente se pueden dar en un bus.

Figura 14.6. Tipos de transferencias de datos que generalmente se pueden dar en un bus.

14.4.3 Esquemas de arbitraje Los esquemas de arbitraje sirven para gestionar el uso del bus por parte de múltiples maestros. Se deben considerar dos factores a la hora de diseñar un esquema de arbitraje: el tipo de prioridad y la imparcialidad. Una clasificación genérica de técnicas de arbitraje puede ser la siguiente: Arbitraje en serie (daisy chain): La línea de concesión de bus (GRANT) recorre los dispositivos desde el más hasta el menos prioritario. Las prioridades se determinan así en función de la posición del dispositivo en el bus. Arbitraje paralelo centralizado: Se utilizan múltiples líneas de petición, por las que los diferentes dispositivos piden acceso al bus de forma independiente. Un árbitro centralizado selecciona uno de entre los dispositivos que han solicitado el bus y le notifica que ahora es el maestro del bus.

Capítulo 14 Buses

525

Arbitraje distribuido por autoselección: Se emplean también múltiples líneas de petición de bus, pero ahora cada dispositivo determina de forma independiente si él es el solicitante de mayor prioridad sin necesidad de un árbitro. Arbitraje distribuido por detección de colisión: Cada dispositivo solicita de forma independiente el bus. En caso de múltiples peticiones simultáneas de bus se produce una colisión. Una vez detectada la colisión se aplica un esquema que determine el dispositivo que será maestro de bus entre las partes en colisión.

14.4.4 Decisiones de diseño En cuanto a las decisiones de diseño, la siguiente tabla resume las diferentes decisiones y su efecto en rendimiento y en el coste: Opción

Alto rendimiento

Bajo coste

Ancho de bus

Líneas de datos y direcciones indep.

Líneas de datos y direcciones multiplexadas

Ancho de datos

Más ancho es más rápido

Menos ancho es más barato

Tamaño de la transferencia

Transferencia bloque de múltiples palabras

Transferencia bloque de una palabra

Maestros de bus

Múltiples maestros (req. arbitraje)

Un único maestro

Transac. partida

Sí. Aumenta ancho de banda (necesita varios maestros)

No. Conexión continua más barata (y con menor latencia)

Temporización

Síncrono

Asíncrono

14.5 Problemas resueltos PROBLEMA 1 Sea un procesador de 32 bits, con un bus de datos de 16 bits, y con un reloj de 8 MHz. El procesador tiene un ciclo de bus cuya duración mínima es igual a cuatro ciclos de reloj. ¿Cuál es la velocidad de transferencia máxima que soporta el sistema? Solución: Tiempo de ciclo %

1 % 125 ns 8 MHz

Ciclo de bus % 4 # 125 ns % 500 ns

526


Esto significa que se pueden llegar a transferir 16 bits cada 500 ns, o lo que es lo mismo: Velocidad de transferencia máxima %

2B 4 MB % 500 ns s

PROBLEMA 2 Considerar dos microprocesadores con buses de datos de 8 y 16 bits, respectivamente. Los dos procesadores son idénticos en todo lo demás y sus ciclos de bus son iguales. a) Suponiendo que todas las instrucciones y operandos son de dos bytes, ¿en qué factor difieren las velocidades de transferencia de los dos microprocesadores? b) ¿Cuál sería la respuesta si en la mitad de los casos los operandos y las instrucciones son de un byte? Solución: a) Durante un ciclo de bus, el microprocesador de 8 bits transfiere 1 byte, mientras que el micro de 16 bits transfiere dos bytes. Esto implica que el micro de 16 bits duplica la velocidad de transferencia del micro de 8 bits. b) Supongamos que realizamos 100 transferencias de operandos e instrucciones, de las cuales 50 son de un byte y 50 son de dos bytes de longitud. El microprocesador de 8 bits necesita de: Número de ciclos en el micro de 8 bits % 50 ! (2 # 50) % 150 En cambio, el microprocesador de 16 bits necesita: Número de ciclos en el micro de 16 bits % 50 ! 50 % 100 Por lo tanto, la velocidad de transferencia de datos difiere en un factor de 1,5. PROBLEMA 3 Un procesador con un bus de 10 MHz tiene una instrucción de incremento de memoria directo que suma 1 al valor almacenado en una posición de memoria. La instrucción tiene cinco etapas: captación del código de operación (4 ciclos de bus), captación de la dirección del operando (3 ciclos), captación del operando (3 ciclos), suma de 1 al operando (3 ciclos), y almacenar el operando (3 ciclos). a) ¿En qué porcentaje se incrementa la duración de la instrucción si hemos de insertar dos ciclos de bus de espera en cada operación de lectura o escritura de memoria? b) Cuando el procesador se encuentra en la etapa de captación de operando cuando el teclado activa una línea de petición de interrupción. ¿Después de cuánto tiempo entra el procesador en el ciclo de reconocimiento de interrupción? c)

Repetir el apartado (a) para el caso en que la operación de incremento necesite 13 ciclos en lugar de 3.

Capítulo 14 Buses

527

Solución: a) Sin los ciclos de espera, la instrucción tarda 16 ciclos de bus. La instrucción necesita de cuatro accesos a memoria, lo que implica 8 estados de espera. La instrucción, incluyendo los ciclos de espera tarda 24 ciclos. Esto supone un incremento del 50%. b) El procesador necesita de otros nueve ciclos para completar la instrucción, es decir, INTA se activará tras: 9 # 100 ns % 900 ns c)

En este caso la instrucción tarda 26 ciclos de bus sin espera y 34 con espera, lo que supone un incremento del 33%.

PROBLEMA 4 Considerar un procesador de 32 bits cuyo ciclo de bus tiene la misma duración que el de un procesador de 16 bits. Asumir que en promedio, el 20% de los operandos e instrucciones son de 32 bits, el 40% son de 16 bits y el 40% restante son de sólo 8 bits. Calcular la mejora que se consigue con la captación de instrucciones y operandos con el procesador de 32 bits. Solución: Sea un conjunto de 100 instrucciones y operandos. En promedio, el conjunto está formado por 20 elementos de 32 bits, 40 de 16 bits, y 40 de un byte. El número de ciclos de bus requeridos por el procesador de 16 bits es: (2 # 20) ! 40 ! 40 % 120 Para el procesador de 32 bits es: 20 ! 40 ! 40 % 100 Esto provoca una mejora del 16,67%. PROBLEMA 5 En la operación de lectura síncrona de la Figura 14.7, el módulo de memoria debe situar el dato en el bus de datos con la suficiente antelación al flanco de bajada de la señal de lectura para asegurar que las señales se han estabilizado. Si el bus de un microprocesador utiliza un bus de 10 MHz y la señal de lectura empieza a caer en el tercer cuarto del ciclo T3: a) Determinar la longitud del ciclo de instrucción de una lectura de memoria. b) ¿Cuándo debería situarse el dato de memoria en el bus como muy tarde? Suponer un tiempo de 20 ns para la estabilización de las líneas de datos.

528


Figura 14.7. Temporización síncrona de las operaciones de bus.

Solución: a) Con una frecuencia de reloj de 10 MHz, el periodo de reloj es de 10.7 s % 100 ns, tenemos que la longitud del ciclo de lectura de memoria es de 3 # 100 ns % 300 ns. b) La señal de lectura comienza a caer a 75 ns del comienzo del tercer ciclo. Por lo tanto, la memoria debe ubicar los datos en el bus no más tarde de 55 ns desde el comienzo de T3. PROBLEMA 6 Considerar un microprocesador con la temporización de lectura de memoria de la Figura 14.7. Después de analizar la situación, un diseñador determina que la memoria no es capaz de proporcionar el dato a leer en un tiempo inferior a 180 ns. a) ¿Cuántos ciclos de espera deben insertarse para conseguir una lectura adecuada de memoria si el reloj de bus opera a 8 MHz? b) Para utilizar los ciclos de espera se añade una línea de estado denominada «READY». Una vez que el procesador ha activado la señal de lectura debe esperar a que la línea «READY» se active para intentar leer el dato de las líneas del bus. ¿Durante qué intervalo de tiempo hay que mantener la señal «READY» en baja para que el procesador inserte los ciclos de espera necesarios?

Capítulo 14 Buses

529

Solución: a) El periodo de reloj es de 8 MHz % 125 ns. Por lo tanto, necesitamos insertar dos ciclos de reloj. b) Según la figura, la señal de lectura comienza a activarse al comienzo de T2. Con el objeto de insertar dos ciclos de reloj, la línea «READY» debe ser puesta en baja al comienzo de T2 y permanecer así durante 250 ns. PROBLEMA 7 Un microprocesador utiliza la temporización que se muestra en la Figura 14.7 para la escritura en memoria. Su fabricante especifica que la extensión temporal de la señal de escritura viene dada por T-50, donde T es el ciclo de reloj en nanosegundos. a) ¿Cuál es la extensión de la señal de escritura si la frecuencia de reloj del bus es de 5 MHz? b) La hoja de características del microprocesador especifica que, tras el flanco de bajada de la señal de escritura, los datos se mantienen válidos durante 20 ns. ¿Durante cuánto tiempo se mantienen válidos los datos que se van a escribir en memoria? c)

¿Cuántos ciclos de espera deberían insertarse si la memoria necesita que los datos se mantengan válidos durante al menos 190 ns?

Solución: a) Un reloj de 5 MHz se corresponde con un periodo de 200 ns. Por lo tanto, la extensión de la señal de escritura es de: Extensión de la señal de escritura % T . 50 ns % 200 ns . 50 ns % 150 ns b) El dato debe permacer válido durante 150 ns ! 20 ns % 170 ns c)

En este caso el dato debe permanecer válido durante 150 ns ! 190 ns % 240 ns. Esto implica utilizar dos ciclos, o lo que es lo mismo, un ciclo de espera.

PROBLEMA 8 El microprocesador 8088 de Intel tiene una temporización de bus para la lectura similar a la de la Figura 14.7, pero necesita cuatro ciclos de reloj del procesador. El dato se mantiene válido en el bus hasta el cuarto ciclo de reloj del procesador. Si la frecuencia de reloj del procesador es de 8 MHz: a) ¿Cuál es la velocidad máxima de transferencia de datos? b) Repetir el apartado anterior suponiendo que hay que insertar un ciclo de espera por cada byte transferido. Solución: a) El periodo de reloj es de 1/8 MHz % 125 ns. Un ciclo de lectura de bus es entonces de: 125 ns # 4 % 500 ns.

530


Esto implica una velocidad de transferencia máxima de: Velocidad de transferencia máxima %

MB 1 byte %2 s 500 ns

b) El ciclo de espera extiende el ciclo de lectura de bus a: 125 ns # 5 % 625 ns. Por lo tanto: Velocidad de transferencia máxima %

MB 1 byte % 1,6 s 625 ns

PROBLEMA 9 Suponer que tenemos un sistema con las siguientes características: Un sistema de memoria y bus que soportan acceso a bloques de entre 4 y 16 palabras de 32 bits. Un bus síncrono de 64 bits a 200 MHz en el que una transferencia de 64 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj. Se necesitan 2 ciclos de reloj entre dos operaciones de bus. El tiempo de acceso a memoria para las 4 primeras palabras es de 200 ns; cada grupo adicional de cuatro palabras se lee en 20 ns. El sistema descrito anteriormente se utiliza para gestionar accesos simultáneos a discos con una velocidad de transferencia de 50 MB/s. Calcular el número de transferencias a disco que se pueden realizar simultáneamente con los dos tamaños de bloque. Solución: 1 bloque de 4 palabras de 32 bits Tiempo requerido para las cuatro primeras palabras: 1 ciclo de reloj para enviar la dirección de memoria ! 200 ns / 5 ns/ciclo % 40 ciclos de tiempo de acceso ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 45 ciclos Por otro lado, el tiempo empleado en 45 ciclos es: 45 ciclos # 5 ns / ciclo % 225 ns Lo que da un ancho de banda: 32 bits palabra 16 B 16 # 103 MB MB % % % 71,11 225 s 225 ns 225 ns s

4 palabras # Ancho de banda %

Capítulo 14 Buses

531

Como la velocidad de transferencia de disco es de 50 MB/s, el número máximo de accesos a disco que podemos gestionar es: Transferencia a disco %

71,11 MB/s %1 50 MB/s

1 bloque de 16 palabras de 32 bits El procedimiento es parecido al caso anterior, con la excepción de que ahora leeremos 16 palabras consecutivas en memoria, lo que implica que tendremos un tiempo de acceso de 40 ciclos al primer bloque de 4 palabras y de 20 ns / 5 ns/ciclo % 4 ciclos en los restantes 3 bloques de 4 palabras: Tiempo requerido para el primer bloque de cuatro palabras: 1 ciclo de reloj para enviar la dirección de memoria ! 200 ns / 5 ns % 40 ciclos de tiempo de acceso ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 45 ciclos Por otro lado, el tiempo empleado en 45 ciclos es: 45 ciclos # 5 ns/ciclo % 225 ns Debemos tener presente que ahora podemos solapar el tiempo de acceso por parte de la memoria con el tiempo de operaciones de bus. Es decir, si observamos la Figura 14.8, el tiempo de acceso del segundo ciclo se puede solapar con el volcado de datos en el bus y el tiempo de espera del mismo.

Figura 14.8. Solapamiento del tiempo de acceso con las operaciones de bus.

Esto implica que cada transferencia adicional de bloque consumirá 4 ciclos de reloj. Tiempo requerido para los tres bloques restantes: ! 3 # ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 4 ciclos

532


Por otro lado, el tiempo empleado en 4 ciclos es: 4 ciclos # 5 ns/ciclo % 20 ns Esto hace un total de 225 ns ! 3 # 20 ns % 285 ns Lo que da un ancho de banda: 16 palabras # Ancho de banda %

285 ns

32 bits palabra

%

64 B 64 # 103 MB MB % % 224,56 285 s 285 ns s

Como la velocidad de transferencia de disco es de 50 MB/s, el número máximo de accesos a disco que podemos gestionar es: Transferencias a disco %

224,56 MB/s %4 50 MB/s

PROBLEMA 10 Suponer que tenemos un sistema con las siguientes características: Un sistema de memoria y bus que soportan acceso a bloques de entre 4 y 16 palabras de 32 bits. Un bus síncrono de 64 bits a 200 MHz en el que una transferencia de 64 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj. Se necesitan 2 ciclos de reloj entre dos operaciones de bus. El tiempo de acceso a memoria para las 4 primeras palabras es de 150 ns; cada grupo adicional de cuatro palabras se lee en 30 ns. Calcular el ancho de banda y la latencia del sistema al leer 256 palabras mediante transferencias que usan: a) Bloques de 4 palabras. b) Bloques de 16 palabras. Calcular también el número de transacciones de bus por segundo en cada caso. Solución: a) 256/4 % 64 bloques de 4 palabras de 32 bits Tiempo requerido para cada bloque de cuatro palabras: 64 # 1 ciclo de reloj para enviar la dirección de memoria ! 150 ns / 5 ns/ciclo % 30 ciclos de tiempo de acceso ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 35 ciclos

Capítulo 14 Buses

533

Lo que hace un total de: Ciclos totales % 64 bloques # 35

ciclos % 2.240 ciclos bloque

Esto implica: Latencia % 2.240 ciclos # 5 Transacciones por segundo %

ns % 11.200 ns ciclo

transacciones 64 transacciones % 5,71 # 106 segundo 11.200 ns B palabras #4 palabra bloque MB % 91,43 11.200 ns s

64 bloques # 4 Ancho de banda %

b) 256/16 % 16 bloques de 16 palabras de 32 bits El procedimiento es parecido al caso anterior, con la excepción de que ahora leeremos 16 palabras consecutivas en memoria, lo que implica que tendremos un tiempo de acceso de 30 ciclos al primer bloque de 4 palabras y de 30 ns / 5 ns/ciclo % 6 ciclos en los restantes 3 bloques de 4 palabras: Tiempo requerido para el primer bloque de cuatro palabras: 1 ciclo de reloj para enviar la dirección de memoria ! 150 ns / 5 ns % 30 ciclos de tiempo de acceso ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 35 ciclos Debemos tener presente que ahora podemos solapar el tiempo de acceso por parte de la memoria con el tiempo de operaciones de bus. Es decir, si observamos el tiempo de

Figura 14.9. Solapamiento del tiempo de acceso con las operaciones de bus.

534


acceso del segundo ciclo se puede solapar con el volcado de datos en el bus y el tiempo de espera del mismo. Esto implica que cada transferencia adicional de bloque consumirá 6 ciclos de reloj. Tiempo requerido para los tres bloques restantes: ! 3 # ! 2 ciclos de tiempo de acceso ! 2 ciclos para transferir los datos (4 palabras, cuando el bus soporta 2 palabras implican 2 ciclos) ! 2 ciclos de reloj entre operaciones de bus % 6 ciclos Esto hace un total de 35 ciclos ! 3 # 6 ciclos % 53 ciclos Este es el número de ciclos empleado en leer un bloque de 16 palabras. Como tenemos que leer 16 bloques, da un total de 53 ciclos # 16 % 848 ciclos. Con esta información podemos calcular los datos solicitados en el enunciado: Latencia % 848 ciclos # 5

Transacciones por segundo %

ns % 4.240 ns ciclo

transacciones 16 transacciones % 3,77 # 106 segundo 4.240 ns B palabras #4 palabra bloque MB % 241,50 4.240 ns s

16 bloques # 16 Ancho de banda % PROBLEMA 11

Suponer que tenemos un sistema de escritura en memoria con las siguientes características: Un bus síncrono de líneas dedicadas: 32 bits para direcciones y 32 bits para datos. El bus trabaja a 200 MHz en el que una transferencia de 32 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj. Se necesitan 2 ciclos de reloj entre dos operaciones de bus. La primera palabra se escribe en memoria 200 ns después de que la dirección está disponible; cada escritura adicional se realiza en 20 ns. La transferencia de una palabra y la escritura de la anterior puede superponerse. Calcular el ancho de banda y la latencia del sistema al escribir 256 palabras de 32 bits mediante transferencias que usan: a) Bloques de 4 palabras. b) Bloques de 8 palabras.

Capítulo 14 Buses

535

Solución: a) 256/4 % 64 bloques de 4 palabras de 32 bits Tiempo requerido % 64 # tiempo de transferencia de 4 palabras % 64 # 1 ciclo de reloj para enviar la dirección de memoria y la primera palabra simultáneamente ! 200 ns / 5 ns/ciclo % 40 ciclos de escritura ! 3 ciclos para enviar las tres palabras restantes ! 2 ciclos de reloj entre operaciones de bus % 46 ciclos Lo que hace un total de: Ciclos totales % 64 bloques # 46

ciclos % 2.944 ciclos bloque

Esto implica: Latencia % 2.944 ciclos # 5

ns % 14.720 ns ciclo

B palabras #4 palabra MB bloque % 69,57 14.720 ns s

64 bloques # 4 Anchos de banda %

b) 256/8 % 32 bloques de 8 palabras de 32 bits Tiempo requerido para cada bloque de ocho palabras: 1 ciclo de reloj para enviar la dirección de memoria y la primera palabra simultáneamente ! 200 ns / 5 ns % 40 ciclos de escritura ! 7 ciclos para enviar las siete palabras restantes ! 4 ciclos de reloj debido a dos operaciones de bus % 52 ciclos Que para 32 bloques hacen 1.664 ciclos. Con esta información podemos calcular los datos solicitados en el enunciado: Latencia % 1.664 ciclos # 5

B palabras #4 palabra bloque MB % 123,08 8.320 ns s

32 bloques # 8 Anchos de banda %

ns % 8.320 ns ciclo

536


PROBLEMA 12 Se desea comparar los anchos de banda máximos de un bus síncrono y otro asíncrono. El bus síncrono tiene un tiempo de ciclo de reloj de 50 ns, y cada transacción del bus requiere 1 ciclo de reloj. El bus asíncrono requiere 20 ns para el protocolo de handshaking. Para ambos la sección de datos tiene una anchura de 32 bits. Encontrar el ancho de banda de ambos buses cuando realizan lecturas de una memoria de 100 ns. Suponer que siempre se lee una palabra. Solución: Analicemos ambos casos: Bus síncrono En caso de utilizar un bus síncrono, el proceso de envío de una palabra tiene 3 fases: 1. Enviar la dirección de memoria (50 ns). 2. Leer el dato (100 ns). 3. Enviar el dato (50 ns). Por lo tanto el tiempo total de envío de 32 bits (una palabra) es de 200 ns. Para hallar el ancho de banda basta con realizar una sencilla regla de tres: 32 bits 4 Bytes % % 20 MB/s 200 ns 200 # 10.9 s Bus asíncrono Tal y como hemos visto en teoría, en el protocolo de handshaking (ver Figura 14.5) hacen falta 7 pasos, cada uno de ellos de 20 ns, sin embargo algunos de los pasos pueden solaparse: Paso 1: la memoria detecta la activación de ReadReq, lee la dirección que hay en el bus y activa Ack. Tiempo 20 ns. Pasos 2, 3 y 4: el periférico libera los buses y desactiva ReadReq, la memoria activa Ack para indicar que va a leer y activa DataRdy para indicar que tiene el dato. Tiempo máximo (3 # 20 ns, 100 ns) % 100 ns. Pasos 5, 6 y 7: el periférico detecta DataRdy y lee los datos, activando al terminar Ack. La memoria ve la activación y libera el bus de datos y desactiva DataRdy. El periférico desactiva su señal de Ack indicando que la transferencia ha terminado. Tiempo 3 # 20 ns % 60 ns. El tiempo total es de: 180 ns. Por lo tanto el ancho de banda máximo para transmitir 4 bytes cada 180 ns será: 4B 4 MB % % 22,22 MB/s 180 ns 0,18 s PROBLEMA 13 Se desea comparar los anchos de banda máximos de un bus síncrono y otro asíncrono. El bus síncrono tiene un tiempo de ciclo de reloj de 30 ns. Y cada transacción requiere 1 ciclo de reloj. El bus asíncrono requiere 25 ns. Para el protocolo de handshaking, en ambos buses, la sección de datos tiene una anchura de 32 bits.

Capítulo 14 Buses

537

Se pide: Calcular el ancho de banda de ambos buses cuando realizan lecturas de una memoria de 60 ns suponiendo que las lecturas siempre son de una palabra. Solución: Bus síncrono Tiene un ciclo de bus de 30 ns. El bus síncrono deberá: 1.

Enviar la dirección a la memoria: 30 ns.

2.

Leer la memoria: 60 ns.

3.

Enviar los datos al dispositivo: 30 ns.

El tiempo total será de 120 ns. El ancho de banda máximo para transmitir 32 bits (4 bytes) cada 120 ns será de: 4B MB % 33,33 120 ns s Bus asíncrono Tal y como vemos, en el protocolo de handshaking hacen falta 7 pasos (Figura 14.5), cada uno de ellos de 25 ns, pero los pasos 2, 3 y 4 pueden solaparse con el acceso a memoria. Paso 1: la memoria detecta la activación de ReadReq, lee la dirección que hay en el bus y activa Ack. Tiempo 25 ns. Pasos 2, 3 y 4: el periférico libera los buses y desactiva ReadReq, la memoria activa Ack para indicar que va a leer y activa DataRdy para indicar que tiene el dato. Tiempo máximo (3 # 25 ns, 60 ns) % 75 ns. Pasos 5, 6 y 7: el periférico detecta DataRdy y lee los datos, activando al terminar Ack. La memoria ve la activación y libera el bus de datos y desactiva DataRdy. El periférico desactiva su señal de Ack indicando que la transferencia ha terminado. Tiempo 3 # 25 ns % 75 ns. El tiempo total es de: 175 ns. Por lo tanto el ancho de banda máximo para transmitir 4 bytes cada 180 ns será: MB 4B % 22,86 s 175 ns PROBLEMA 14 Se dispone de un bus asíncrono de 128 bits (4 palabras) para enviar datos de memoria a un dispositivo de E/S. Una petición del dispositivo implica leer 16 palabras de 32 bits de la memoria. El bus sigue un protocolo de handshaking como el mostrado en la Figura 14.5, salvo que éste es extendido para que la memoria pueda continuar enviando bloques adicionales de datos hasta que la transacción se complete. Asumiendo que cada comunicación en el protocolo lleva 20 ns y que el acceso a memoria es de 60 ns, ¿cuánto tiempo lleva completar una transferencia?, ¿cuál es el ancho de banda de este bus?

538


Solución: Para realizar una transferencia de 16 palabras, se enviarán 4 bloques de 4 palabras cada uno a través del bus. En la Figura 14.5, la señal ReadReq está destinada al envío de un bloque de datos a través del bus, no a la transferencia de bloques consecutivos. Es por esto que al protocolo original de handshaking debemos añadir una línea adicional. Esta línea generalmente es conocida como «Burst Request» o BurstReq. El protocolo de handshaking para bloques consecutivos queda entonces como sigue: 0.

El protocolo comienza con el maestro (el dispositivo de E/S) poniendo una dirección de memoria en el bus de datos y activando la señal de petición de lectura (ReadReq y BurstReq).

1.

La memoria ve ReadReq y BustReq y coge la dirección de memoria del bus de datos (comienzo de las 16 palabras), activando la señal de aceptación (Ack).

2.

El dispositivo ve activa la señal de Ack y libera el bus de datos y desactiva la señal de petición de lectura ReadReq, que sirve de aviso a la memoria, sin embargo BurstReq permanece activa.

3.

La memoria ve la desactivación de la señal de petición y contesta asimismo con la desactivación de la señal de Ack.

4.

Este paso comienza cuando BurstReq está activa y Ack está en baja y la memoria tiene listas las 4 palabras, las pone en el bus y activa la señal que indica que el dato está listo (DataRdy).

5.

El dispositivo ve la señal DataReady, con lo que sabe que el dato está listo en el bus y realiza su lectura. Cuando completa la operación activa la señal de Ack.

6.

La memoria ve la señal de Ack, lo que le dice que el maestro ya tiene el dato leído, y desactiva la señal DataRdy y libera el bus de datos.

7.

El maestro responde a la desactivación de DataRdy con la bajada de su señal de Ack, pero continúa con la señal BurstReq activa si se deben leer más datos. Por tanto, el paso 4 será el siguiente si BurstReq sigue activa.

8.

Si las últimas 4 palabras se han leído, el dispositivo desactiva BurstReq.

Considerando que cada comunicación en el protocolo lleva 20 ns y que el acceso a memoria lleva 60 ns, una transferencia de bus tardará lo siguiente: Paso 1: 20 ns (la memoria recibe la dirección y comienza su lectura, el dato estará disponible en el paso 5). Pasos 2, 3, 4: Será el máximo del tiempo de protocolo o la lectura de memoria, esto es máximo (3 # 20 ns, 60 ns) % 60 ns r 4 palabras. Pasos 5, 6, 7, 4: Comienza el bucle de lecturas, máximo (4 # 20 ns, 60 ns) % 80 ns r 8 palabras. Pasos 5, 6, 7, 4: Lo mismo, máximo (4 # 20 ns, 60 ns) % 80 ns r 12 palabras. Pasos 5, 6, 7, 4: Lo mismo, máximo (4 # 20 ns, 60 ns) % 80 ns r 16 palabras. TOTAL en completar una transferencia: 320 ns.

Capítulo 14 Buses

539

Con lo que podemos calcular el ancho de banda: 16 palabras # Ancho de banda %

4B palabra

320 ns

% 200

MB s

PROBLEMA 15 La memoria de un computador consta de N módulos independientes conectados a un bus de memoria común. Al comienzo de una operación de escritura en memoria, el bus está ocupado por las señales de datos, dirección y control durante 20 ns. Durante los 80 ns siguientes, el módulo de memoria direccionado completa el ciclo de escritura, aceptando y almacenando el dato. Las operaciones de los módulos de memoria pueden solaparse pero sólo puede haber una petición en un instante de tiempo. Indique cuál es el número de módulos de memoria conectados al bus si la velocidad máxima posible con la que se pueden escribir los datos en memoria es de 50 Mpalabras/s. Solución: El ciclo de escritura en los módulos de memoria se muestra gráficamente en la Figura 14.10.

Figura 14.10.

Ciclo de escritura en un módulo de memoria.

El tiempo de ciclo de lectura es de 100 ns. El módulo de memoria utiliza el bus en exclusiva durante los primeros 20 ns, mientras que en los restantes 80 ns, cualquier otro módulo puede hacer uso del bus. Según se indica en el enunciado, la velocidad máxima de escritura en memoria es de 50 Mpalabras/s. Considerando que los ciclos de escritura se solapan al máximo, esa velocidad máxima se corresponde con un número de módulos de memoria mayor que cuatro.

Figura 14.11. Ciclo de escritura en 2 módulos de memoria.

Figura 14.11: N % 2 Velocidad máxima de transferencia %

2 palabras Mpal % 20 100 ns s

540




Mpal 3 palabras % 30 s 100 ns



Mpal 4 palabras % 40 s 100 ns




Capítulo 14 Buses

541




PROBLEMA 16 Se considera un computador con una longitud de palabra de 48 bits. Cada transmisión sobre el bus multiplexado necesita 750 ns para activar las diferentes órdenes del protocolo de comunicación y transmitir el dato por el bus. La velocidad de transferencia desde el disco es de 107 bits/s y el tiempo de ciclo de la memoria principal es de 600 ns. a) ¿Qué formato del bus se escogería? b) Representar el cronograma de los sucesos que tienen lugar durante la transmisión de una operación de entrada continua desde el disco a la memoria principal. c)

¿Qué fracción del ancho de banda de la memoria principal se consume en una operación de E/S del disco?

Solución: a) Para elegir un formato de bus, hay que estudiar el tipo de dispositivos que hacen uso de él; en este caso, la memoria principal y el disco. Ambos dispositivos tienen unas velocidades de transferencia muy distintas. El tiempo que el disco tarda en disponer de los 48 bits que componen una palabra completa es: 48 bits % 48 # 10.7 s % 4.800 ns bits 7 10 s Este tiempo es mucho mayor que los 750 ns que tarda el bus en transmitir esa palabra o que los 600 ns que emplea la memoria principal en almacenarla. Es aconsejable utilizar un bus con temporización asíncrona. Con este tipo de temporización pueden compartir el bus una mezcla de dispositivos lentos y rápidos. Por otro lado, no es necesario utilizar un bus dedicado a E/S ya que una única unidad de disco, al ser tan relativamente lenta, no lo justifica.

542


b) En la Figura 14.16 se representa el cronograma de sucesos que tienen lugar durante una operación de entrada desde el disco a la memoria principal.

Figura 14.16. Cronograma de transferencia.

Los números del cronograma se corresponden con los siguientes eventos:

c)

1.

El disco finaliza la lectura de una palabra completa y se inicia el proceso de su transferencia a través del bus. Durante 750 ns se activan las señales del protocolo de comunicaciones y se coloca el dato en el bus.

2.

Las diferentes señales de protocolo han sido activadas y el dato está estable en el bus. La memoria comienza a almacenar la palabra, lo que llevará 600 ns.

3.

La memoria finaliza el almacenamiento de la palabra y el dato se puede retirar del bus. Sin embargo, el siguiente dato todavía no está disponible.

El ancho de banda se puede definir, en este caso, como la máxima velocidad de transferencia. Para el disco su valor viene indicado directamente en el enunciado del problema: bits s MB % 12,5 Bdisco % 107 bps % bits s 8 byte 107

El ancho de banda de la memoria se calcula teniendo en cuenta que es capaz de almacenar una palabra de 48 bits cada 600 ns. Bmem. %

48 bits MB % 8 # 107 bps % 10 600 ns s

Para calcular la fracción basta con dividir ambas cantidades: MB Bdisco s % % 0,125 r 12,5% MB Bmem. 10 s 1,25

Capítulo 14 Buses

543

En operaciones de E/S entre la memoria y el disco, tan sólo se produce una ocupación de 12,5% de la velocidad de transferencia de la memoria. Esto permitiría a la memoria, si fuera necesario y el bus lo aceptara, atender simultáneamente a varias unidades de disco. PROBLEMA 17 Un computador tiene un bus de sistema de 64 líneas de datos que trabaja a una frecuencia de 33 MHz. a) Determinar cuántos contralores SCSI se pueden conectar al bus antes de saturarlo, teniendo en cuenta que el bus SCSI tiene 16 líneas de datos y trabaja a una frecuencia de 10 MHz. b) Al bus SCSI se conectan discos cuya velocidad de transferencia es 7 MB/s. Determinar cuántos discos se pueden conectar al bus SCSI sin llegar a saturarlo. Solución: a) Ancho de banda El ancho de banda del bus es: 8

B ciclos # 33 # 106 % 264 MB/s ciclo s

El ancho de banda del controlador SCSI es: 2 B # 10 MHz % 20 MB/s Por lo tanto se pueden conectar un total de: 264 % 13 controladores 20 b) Número máximo de discos Si el ancho de banda del controlador es de 20 MB/s, se le pueden conectar un total de: 20 % 3 discos 7 PROBLEMA 18 Un computador dispone de un canal multiplexor que controla 5 unidades de disco y 10 unidades de cinta. Las unidades de disco tienen una velocidad de transferencia de 106 bytes/s, y las de cinta de 2 # 105 bytes/s. Si para la transferencia de un byte del canal multiplexor a memoria principal se utiliza el bus del sistema durante 200 ns, ¿cuál es la velocidad máxima de transferencia de E/S agregada en este sistema? Solución: El canal multiplexor es capaz de atender a varios dispositivos simultáneamente. La máxima velocidad agregada se logrará cuando todos ellos estén transmitiendo. En este caso, la máxima velocidad de transferencia sería: 5 # 106 ! 10 # 2 # 105 % 7 # 106 bytes/segundo

544


Ahora bien, si para transferir un byte hacen falta 200 ns % 200 # 10.9 s, en un segundo sólo se podrá transferir un máximo de 1s 200 # 10.9

s B

%

1 # 109 B % 5 # 106 B 200

en lugar de los 7 # 106 bytes/segundo que cabría esperar. Por lo tanto, el bus no es capaz de proporcionar el ancho de banda suficiente. Es decir, la máxima velocidad agregada viene dada por la limitación en la velocidad de transferencia entre el canal multiplexor y la memoria. PROBLEMA 19 Un sistema tiene la siguiente jerarquía de buses:

Figura 14.17.

Jerarquía de buses.

Capítulo 14 Buses

545

a) ¿Cuál es la velocidad del bus de sistema? b) ¿Cuál es la velocidad de los buses de expansión? c)

¿Cuál es la velocidad de los buses de entrada/salida?

d) ¿Cuántos controladores SCSI se pueden conectar al bus antes de saturarlo? e)

¿Cuántos discos se pueden conectar al SCSI sin llegar a saturarlo?

f)

¿Cuántos fax-modems pueden conectarse al bus EISA sin llegar a saturarlo?

Solución: a) 8 bytes # 200 MHz % 1.600 MB/s b) 8 bytes # 66 MHz % 528 MB/s c)

4 bytes # 8 MHz % 32 MB/s

d) Controlador SCSI r 4 B # 20 MHz % 80 MB/s e)

80 % 4 discos 20

f)

56.000 bps % 7.000 bytes/s % 7 # 103 MB/s 32 # 103 % 4.571 fax/modems 7

PROBLEMA 20 Suponer un sistema de arbitraje de 4 dispositivos master conectados a un bus con prioridad decreciente (Prioridad M1 b M2 b M3 b M4). Considere un tiempo de respuesta de 25 ns. En este sistema se produce la siguiente secuencia: M4 pide el bus en t % 100 ns y lo utiliza durante 50 ns, M2 lo pide en t % 200 ns por 50 ns, M3 en t % 330 ns y por 200 ns y finalmente M1 pide el control del bus en t % 400 ns hasta un nuevo evento. Dibujar el cronograma del sistema para un protocolo de 3 hilos. Solución: Según el enunciado el esquema de comunicaciones sería el siguiente:

546


El proceso de comunicación seguirá los siguientes pasos: Evento Instante de tiempo (ns) M4 pide el bus 100 Arbitro recibe req 125 Arbitro envía grant a M1 150 M1 envía grant a M2 175 M2 envía grant a M3 200 M2 pide el bus 200 Arbitro recibe req 225 M3 envía grant a M4 y se activa BUS BUSY 225 M4 libera el bus 275 Arbitro envía grant a M1 300 M1 envía grant a M2 325 M2 controla el bus 325 M3 pide el bus 330 Arbitro recibe req 355 M2 libera el bus 375 Arbitro envía grant a M1 400 M1 pide el bus 400 M1 envía grant a M2 425 Arbitro recibe req 425

14.6 Problemas propuestos PROBLEMA 1 Suponer que tenemos un sistema con las siguientes características: Un sistema de memoria y bus que soportan acceso a bloques de 4 o 16 palabras de 32 bits. Un bus síncrono de 64 bits a 200 MHz en el que una transferencia de 64 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj. Se necesitan 2 ciclos de reloj entre dos operaciones de bus. El tiempo de acceso a memoria para las 4 primeras palabras es de 200 ns; cada grupo adicional de cuatro palabras se lee en 20 ns. La transferencia de los datos leídos más recientemente y la lectura de las siguientes 4 palabras puede superponerse. Encontrar la latencia y el ancho de banda del bus al leer 256 palabras de memoria con ambos tamaños de bloque. PROBLEMA 2 Suponer que tenemos un sistema con las siguientes características: Un sistema de memoria y bus que soportan acceso a bloques de palabras de 32 bits. Un bus síncrono de 64 bits a 200 MHz en el que una transferencia de 64 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj.

Capítulo 14 Buses

547

Se necesitan 2 ciclos de reloj entre dos operaciones de bus. El tiempo de acceso a memoria para las 4 primeras palabras es de 150 ns; cada grupo adicional de cuatro palabras se lee en 30 ns. Encontrar la latencia y el ancho de banda del bus al leer 256 palabras de memoria. Considere tamaños de bloque de 4, 5, 6 ... 16 palabras y representar los datos en una gráfica, analizando los resultados. PROBLEMA 3 Suponer que tenemos un sistema con las siguientes características: Un sistema de memoria y bus que soportan acceso a bloques 4 o 16 palabras de 32 bits. Un bus síncrono de 64 bits a 200 MHz en el que una transferencia de 64 bits requiere un ciclo de reloj. El envío de la dirección a memoria también requiere un ciclo de reloj. Se necesitan 2 ciclos de reloj entre dos operaciones de bus. El tiempo de acceso a memoria para las 4 primeras palabras es de 150 ns; cada grupo adicional de cuatro palabras se lee en 30 ns. Encontrar la latencia y el ancho de banda del bus al leer 4, 5, 6, ..., 256 palabras de memoria. Considerar ambos tamaños de bloque y representar los datos en una gráfica, analizando los resultados. PROBLEMA 4 Se desea comprobar los anchos de banda máximos de un bus síncrono y otro asíncrono. El bus síncrono tiene un tiempo de ciclo de reloj de 50 ns, y cada transición de bus requiere un ciclo de reloj. El bus asíncrono requiere 40 ns para el protocolo de handshaking. En ambos buses, la sección de datos tiene una anchura de 32 bits. Encontrar el ancho de banda de ambos buses cuando realizan lecturas de una memoria de 200 ns. Suponger que las lecturas son siempre de una palabra. PROBLEMA 5 El microprocesador de ocho bits 8086 de Intel utiliza un bus de 16 bits que puede transferir 2 bytes a la vez, siendo par la dirección del byte menos significativo. Sin embargo, el 8086 permite palabras de operandos alineadas tanto en direcciones pares (even-aligned) como impares (odd- aligned). Si se hace referencia a una palabra alineada en una dirección impar se necesitan dos ciclos, cada uno de cuatro ciclos de reloj de bus para transferir la palabra. Considerar una instrucción del 8086 que utiliza dos operandos de 16 bits. ¿Cuánto tiempo se tarda en captar los dos operandos según las distintas posibilidades? Considerar una frecuencia de reloj de 4 MHz y que no hay estados de espera. PROBLEMA 6 La memoria de un computador consta de 4 módulos conectados a un bus de memoria común. Cuando se realiza una petición de escritura, el bus está ocupado por las señales de datos, dirección y control durante 50 ns. En esos mismos 50 ns y en los 200 ns siguientes, el módulo de memoria direccionado ejecuta 1 ciclo aceptando y almacenando el dato. Las operaciones

548


de los módulos pueden solaparse, pero sólo puede haber una petición por instante de tiempo. Si tC representa el tiempo de ciclo de escritura, calcular cuál es la velocidad máxima de escritura. PROBLEMA 7 Suponer un sistema de arbitraje de 4 dispositivos master conectados a un bus con prioridad decreciente (Prioridad M1 b M2 b M3). Considerar un tiempo de respuesta de 25 ns. Se produce la siguiente secuencia: M3 pide el bus en t % 100 ns y lo utiliza durante 50 ns, M2 lo pide en t % 200 ns por 50 ns, M1 en t % 290 ns y por 75 ns. Dibujar el cronograma del sistema para a) un protocolo de arbitraje de 3 hilos y b) un protocolo daisy-chain. PROBLEMA 8 Considerar la disposición de las líneas de petición del bus (BR) y de autorización del bus (BG) mostradas en la Figura 14.18.

Figura 14.18.

Esquema de arbitraje de bus.

a) ¿Cómo debería el dispositivo generar BR? b) Interpretar la entrada BGN. c)

Generar la salida BGO.

d) Especificar el cronograma de las señales y la prioridad de cada dispositivo. e) Identificar los posibles conflictos que pueden aparecer en este sistema e indicar la manera de solucionarlos. PROBLEMA 9 El bus de E/S de un computador posee un mecanismo de arbitraje por encadenamiento (daisy chain) y tiene conectados k dispositivos (d1, d2, ..., dk). Cada dispositivo di utiliza una fracción ai de la capacidad del bus, que tiene un valor normalizado a 1: k

0 a ai a 1,

siendo

; ai % 1

i%1

Capítulo 14 Buses

549

a) ¿Cómo se deberían conectar los dispositivos para conseguir el máximo de la capacidad media sobrante? Se define la capacidad sobrante de un dispositivo como 1 menos la suma de las capacidades utilizadas por todos los dispositivos que tienen una prioridad superior. b) Comentar brevemente lo que significan esos resultados y dar un ejemplo de cuándo no se pueden aplicar. PROBLEMA 30 A continuación se describen varios bloques usados en un sistema de E/S que tiene un bus síncrono procesador-memoria que funciona a 200 MHz y uno o varios adaptadores de E/S para realizar la interfaz de buses de E/S al bus procesador-memoria: Sistema de memoria: Dispone de una interfaz de 32 bits y soporta transferencia de 4 palabras. Dispone de líneas separadas para direcciones y datos. Para las escrituras a memoria acepta una palabra por ciclo durante 4 ciclos consecutivos y luego requiere de 4 ciclos para almacenar los datos y estar disponible para una nueva transacción. DMA: Los adaptadores de E/S utilizan DMA para transferir los datos entre los buses de E/S y el bus procesador-memoria. El controlador de DMA realiza el arbitraje para acceder al bus procesador-memoria y envía/recibe bloques de 4 palabras hacia/desde el sistema de memoria. El controlador de DMA puede gestionar hasta 8 discos. La inicialización de una operación de E/S (incluidos el posicionamiento y el acceso) requiere de 1 ms, durante el cual el controlador no puede iniciar un nuevo acceso, aunque sí pueden completarse operaciones pendientes. Bus de E/S: El bus de E/S es síncrono con un ancho de banda de 10 MB/s. El tamaño de cada transferencia es de 1 palabra. Discos: Los discos tienen un tiempo de posicionamiento medio más latencia de rotación de 12 ms. Los discos tienen un ancho de banda para la lectura/escritura de 5 MB/s. Encuentre el tiempo necesario para leer un sector de 16 KB del disco a memoria, suponiendo que ésta es la única actividad en el bus.

a

Abánades, M. A., Cuesta, A., Granados A., Joglar, N., Martín. D. Exámenes finales: La solución del profesor. Felipe II Libros, 2007. Angulo Usategi, J. M. Sistemas digitales y tecnología de computadores. Paraninfo, 2002. Baena, C.; Bellido, J.; Molina, A.; Parra, M.; Valencia, M. Problemas de circuitos y sistemas digitales. McGraw-Hill, 1997. Beekman G. Introducción a la informática. Pearson, 2004. 6.a edición. Ercegovac, M., Lang, T. Digital Systems and hardware/firmware algorithms. John Wiley & Sons, 1985. Floyd, T. L. Fundamentos de sistemas digitales. Prentice Hall, 2006, 9.a edición. Gajski, D. D. Principios de diseño digital. Prentice Hall, 1997. Gascón de Toro, M., Leal Hernández, A., Peinado Bolos, V. Problemas prácticos de diseño lógico, hardware. Paraninfo, 1990. Hamacher, C., Vranesik, Z., Zaky, F. Computer Organization. McGraw-Hill, 2002. 5.a edición. Hayes, J. B. Introducción al diseño lógico digital. Addison Wesley, 1996. Hennessy, J. L., Patterson, D. A. Computer Architecture. A Quantitative Approach. Morgan Kaufmann, 2007, 4.a edición. Hermida R., Corral A. M. del, Pastor E. y Sánchez F. Fundamentos de computadores. Síntesis, 1998. Hill, F. J., Peterson, G. R. Introduction to Switching Theory & Logical Design. John Wiley & Sons, 1981, 3.a edición. Irvine, K. R. Lenguaje ensamblador para computadoras basadas en intel. Prentice Hall, 2007, 5.a edición. Koren, I. Computer arithmetic algorithms, A. K. Peters, 2002, 2.a edición. Mano, M. Ingeniería computacional: diseño del hardware. Prentice Hall, 1991.

552

Bibliografía

Mano, M. Diseño digital. Prentice Hall, 2003, 3.a edición. Miguel, P. de y otros. Problemas de estructura de computadores. Paraninfo, 1990. Murdocca, M. J., Heuring, V. P. Principios de arquitectura de computadoras. Prentice Hall, 2002. Ortega J., Anguita M., Prieto A. Arquitectura de computadores. Thomson-Paraninfo, 2004. Parhami, B. Computer arithmetic: algorithms and hardware design. Oxford University Press, 2000. Pastor E. y Sánchez F. La máquina rudimentaria: un procesador pedagógico. III Jornadas de Enseñanza Universitaria sobre Informática JENUI’97, junio 1997, págs. 395-402. Patterson, D. A., Hennessy, J. L. Computer Organization and Design: The Hardware/Software Interface. Morgan Kaufmann, 2005, 3.a edición. Roth, Charles H. Fundamentos de diseño lógico. Thomson, 2004, 5.a edición. Septién, J., Mecha, H., Moreno, R., Olcoz, K. La familia del MC68000. Lenguaje ensamblador: conexión y programación de interfaces. Síntesis, 1995. Stallings, W. Organización y arquitectura de computadores. Prentice Hall, 2007, 7.a edición.

Por otro lado, una vez explicada y estudiada la teoría, el libro es además una herramienta de autoevaluación. En este sentido, desde nuestra experiencia, recomendamos al lector que no mire las soluciones, sino que previamente se enfrente al problema e intente resolverlo por cuenta propia, acudiendo como último recurso al breve apunte teórico que hay al comienzo de cada capítulo. El libro recopila más de 250 problemas resueltos y otros tantos solamente enunciados. La mayor parte de ellos han sido propuestos en exámenes de Diplomatura y Licenciatura en Informática a lo largo de los 10 últimos años. Los temas que abarca se pueden agrupar en las siguientes materias: • Representación de la información • Diseño Combinacional • Diseño Secuencial • Diseño Algorítmico • Ensamblador • Modos de direccionamiento • Formato de instrucciones • Ruta de datos y Unidad de Control • Memoria • Buses • Entrada/Salida • Segmentación • Rendimiento


Este libro pretende ser un complemento práctico a la extensa bibliografía teórica en el área de Diseño Lógico, Estructura y Arquitectura de Computadores. En estas asignaturas el alumno se enfrenta a un gran número de métodos y conceptos, que naturalmente debe aprender, pero cuya finalidad es ser aplicados en problemas reales. Por ello creemos que disponer de una colección de casos prácticos, presentados en forma de ejercicios, puede aclarar los conceptos que se están estudiando en estas asignaturas.


Cuesta Hidalgo Lanchares Risco ISBN 978-84-8322-591-2

9 788483 225912

www.pearsoneducacion.com

Problemas de fundamentos.indd 1

Alfredo Cuesta Infante José Ignacio Hidalgo Pérez Juan Lanchares Dávila José Luis Risco Martín 20/7/11 13:25:07

Problemas de Fundamentos y Estr - Alfredo Cuesta Infante

Recommend Documents