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.

Problemas de fundamentos y estructura de computadores

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 estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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).

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

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

Problemas de fundamentos y estructura de computadores

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).

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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

d) Ninguna de las anteriores

c)

(1010)C1

d) Ninguna de las anteriores

c)

Overflow

d) Ninguna de las anteriores

(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

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

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,

ⵧ ..Ninguna de las anteriores

c)

(A42)16 %

ⵧ ..(1042)10,

ⵧ ..(5102)8,

ⵧ ..(1010 0100 0010)BCD,

ⵧ ..Ninguna de las anteriores

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

ⵧ ..[.31, 31],

ⵧ ..[.32, 32],

ⵧ ..[.31, 32],

ⵧ ..Ninguna de las anteriores

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

ⵧ ..Ninguna de las anteriores

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

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

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

ⵧ ..(A)BCD no se puede representar

ⵧ ..Ninguna de las anteriores

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

ⵧ ..[.4, !4]

ⵧ ..[.3, !3]

ⵧ ..[.4, !3]

ⵧ ..Ninguna de las anteriores

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

ⵧ ..Ninguna de las anteriores

24

Problemas de fundamentos y estructura de computadores

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

ⵧ ..Ninguna de las anteriores

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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,

Capítulo 2 Sistemas combinacionales

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

41

42

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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í

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

Á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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 2 Sistemas combinacionales

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

– 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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

La implementación basada en contador es:

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

97

98

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 3 Sistemas secuenciales

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

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

129

130

Problemas de fundamentos y estructura de computadores

Y la tabla de salidas será: Estado

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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

135

Y la tabla de salidas será: Estado

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

Problemas de fundamentos y estructura de computadores

Solución:

Cód.

Op. ALU

0 0 1 1

A!B B.A AA Evalua B

0 1 0 1

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

137

138

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

—

—

—

—

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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:

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

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

155

156

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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:

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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:

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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.

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

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

Problemas de fundamentos y estructura de computadores

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

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

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

Problemas de fundamentos y estructura de computadores

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

Las instrucciones realizan las siguientes fases: Instrucción

Estados

ADDI

FETCH* ! DECO ! ARIT

SUBI

FETCH* ! DECO ! ARIT

ADD

FETCH* ! DECO ! ARIT

ADDI

FETCH* ! DECO ! ARIT

ASR

FETCH* ! DECO ! ARIT

AND

FETCH* ! DECO ! ARIT

LOAD

FETCH* ! DECO ! LOAD

STORE

FETCH* ! DECO ! STORE

BR

FETCH* ! DECO ! SALTO

BEQ

FETCH* ! DECO ! SALTOⱅ

BL

FETCH* ! DECO ! SALTOⱅ

BLE

FETCH* ! DECO ! SALTOⱅ

BNE

FETCH* ! DECO ! SALTOⱅ

BGE

FETCH* ! DECO ! ALTOⱅ

BG

FETCH* ! DECO ! SALTOⱅ

* 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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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)

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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).

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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.

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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

Capítulo 5 Estructura de un computador sencillo

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

Problemas de fundamentos y estructura de computadores

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:

Capítulo 5 Estructura de un computador sencillo

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

Dirección IR7-0 0000 0110

STORE R7, 06(R7)

04

8001

Salto

Código IR15-14 10

COND 000 IR13-11 IR10-8 000 000

Dirección IR7-0 0000 0001

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

Problemas de fundamentos y estructura de computadores

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