MAN30 Fundamentos Computadores PDF

RAFAEL ASENJO PLAZA
ELADIO GUTIÉRREZ CARRASCO

JULIÁN RAMOS CÓZAR
FUNDAMENTOS DE
LOS COMPUTADORES
UNIVERSIDAD DE MALAGA / MANUALES

Departamento de Arquitectura de Computadores
Universidad de Málaga
Fundamentos de los Computadores
Rafael Asenjo Plaza

Eladio Gutierrez Carrasco
Julián Ramos Cózar
Málaga, 2001
Quinta edición, febrero 2006
© Los autores
© Publicaciones y Divulgación Científica. Universidad de Málaga.
Diseño de Ia colección: J. M. Mercado
I.S.B.N.: 84-7496-855-0
Depósito Legal: MA-141/2006
Imprime: Imagraf Impresores, S.A. Tel.: 952 32 85 97
Esta obra está bajo una licencia de Creative Commons

Reconocimiento-NoComercial-SinObraDerivada 4.0 Internacional:
http://creativecommons.org/licenses/by-nc-nd/4.0/legalcode
Cualquier parte de esta obra se puede reproducir sin autorización
pero con el reconocimiento y atribución de los autores.
No se puede hacer uso comercial de la obra y no se puede alterar,
transformar o hacer obras derivadas.
Aviso
Este material ha sido preparado por:

Rafael Asenjo Plaza
Eladio Gutierrez Carrasco
Julián Ramos Cózar
Dept. de Arquitectura de Computadores. Universidad de Málaga.
c Esta obra está bajo una Licencia Creative Commons Atribución-NoComercial-

SinDerivar 4.0 Internacional.
b Debe dar crédito en la obra en la forma especificada por el autor o

licenciante.
e El licenciante permite copiar, distribuir y comunicar publicamente la

obra. A cambio, esta obra no puede ser utilizada con fines comerciales – a
menos que se obtenga el permiso expreso del licenciante.
d El licenciante permite copiar, distribuir, transmitir y comunicar públi-

camente solamente copias inalteradas de la obra – no obras derivadas basadas
en ella.
Índice
Índice de Figuras IX
Índice de Tablas XII
Prefacio XIII
1.- Introducción a los Computadores 1

1.1. Naturaleza de los computadores . . . . . . . . . . . . . . . . . . 3
1.2. Antecedentes históricos . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1. Progresos mecánicos . . . . . . . . . . . . . . . . . . . . 3
1.2.2. Progresos electromecánicos. Relés . . . . . . . . . . . . . 4
1.2.3. Progresos electrónicos . . . . . . . . . . . . . . . . . . . 5
1.3. Arquitectura de von Neumann . . . . . . . . . . . . . . . . . . 6
1.4. Generaciones de computadores . . . . . . . . . . . . . . . . . . 8
1.5. Niveles de descripción . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.1. Especificación e implementación de un sistema . . . . . 11
2.- Representación de la Información 13

2.1. Clasificación de la información . . . . . . . . . . . . . . . . . . 15
2.2. Representación de los datos . . . . . . . . . . . . . . . . . . . . 17
2.2.1. Datos Numéricos . . . . . . . . . . . . . . . . . . . . . . 17
2.2.2. Enteros . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.2.3. Reales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.4. Datos No Numéricos. Caracteres . . . . . . . . . . . . . 26
2.3. Representación de las instrucciones . . . . . . . . . . . . . . . . 26
2.3.1. Formatos de instrucciones. Introducción . . . . . . . . . 27
2.3.2. Modos de direccionamiento . . . . . . . . . . . . . . . . 29
2.3.3. Modificaciones sobre los modos de direccionamiento . . 30
2.3.4. Número de direcciones . . . . . . . . . . . . . . . . . . . 32
i
ii FUNDAMENTOS DE LOS COMPUTADORES
2.3.5. Códigos de operación . . . . . . . . . . . . . . . . . . . . 33

2.3.6. Tipos de instrucciones . . . . . . . . . . . . . . . . . . . 33
Relación de Problemas . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.- Procesador Central 39

3.1. Introducción. Estructura básica de un procesador . . . . . . . . 41
3.1.1. Caracterı́sticas principales del procesador . . . . . . . . 42
3.2. Subsistemas de datos y de control . . . . . . . . . . . . . . . . . 45
3.2.1. Registros . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.2. Unidad de Datos . . . . . . . . . . . . . . . . . . . . . . 47
3.2.3. Unidad de Control . . . . . . . . . . . . . . . . . . . . . 49
3.3. Ciclo máquina y estados de un procesador . . . . . . . . . . . . 50
3.3.1. Modos de secuenciamiento . . . . . . . . . . . . . . . . . 51
3.3.2. Técnica pipeline de instrucciones . . . . . . . . . . . . . 52
3.4. Ejemplo: Microprocesador 8086 . . . . . . . . . . . . . . . . . . 53
3.4.1. Caracterı́sticas generales . . . . . . . . . . . . . . . . . . 53
3.4.2. Registros . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.4.3. Gestión de memoria . . . . . . . . . . . . . . . . . . . . 55
Esquema de almacenamiento . . . . . . . . . . . . . . . 55
Modos de direccionamiento . . . . . . . . . . . . . . . . 56
3.4.4. Sistema de interrupciones . . . . . . . . . . . . . . . . . 57
3.4.5. Ensamblador del 8086 . . . . . . . . . . . . . . . . . . . 58
3.4.6. La pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.4.7. Módulo fuente . . . . . . . . . . . . . . . . . . . . . . . 59
4.- Sección de Control 71

4.1. Introducción. Control cableado versus microprogramado . . 73
4.2. Diseño de una unidad de control microprogramada . . . . . . . 76
4.2.1. Caracterı́sticas temporales . . . . . . . . . . . . . . . . 80
4.2.2. Ejemplos de microprograma . . . . . . . . . . . . . . . . 81
4.2.3. Capacidad de salto . . . . . . . . . . . . . . . . . . . . . 83
4.2.4. Microprogramación del conjunto de instrucciones . . . . 85
4.3. Diseño avanzado . . . . . . . . . . . . . . . . . . . . . . . . . . 90
4.3.1. Caracterı́sticas temporales . . . . . . . . . . . . . . . . . 91
4.3.2. Codificación de las microinstrucciones . . . . . . . . . . 95
4.3.3. Expansión funcional del “datapath”: ALU . . . . . . . . 97
4.3.4. Capacidad de salto y constantes en la microinstrucción . 98
4.3.5. Microprogramación del conjunto de instrucciones . . . . 99
ÍNDICE iii
4.4. Diseño de una unidad de control cableada . . . . . . . . . . . . 103

4.4.1. Método de los elementos de retardo . . . . . . . . . . . 104
4.4.2. Método del contador de secuencias . . . . . . . . . . . . 108
5.- Sección de Procesamiento 141

5.1. Aritmética de Punto Fijo . . . . . . . . . . . . . . . . . . . . . 143
5.2. Suma y Resta . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
5.2.1. Algoritmos de suma y resta . . . . . . . . . . . . . . . . 143
Binario natural . . . . . . . . . . . . . . . . . . . . . . . 143
Signo/Magnitud . . . . . . . . . . . . . . . . . . . . . . 144
Complemento a 1 . . . . . . . . . . . . . . . . . . . . . . 145
Complemento a 2 . . . . . . . . . . . . . . . . . . . . . . 146
5.2.2. Implementación de un sumador . . . . . . . . . . . . . . 146
Sumador serie . . . . . . . . . . . . . . . . . . . . . . . . 146
Sumadores paralelos . . . . . . . . . . . . . . . . . . . . 147
5.3. Producto de enteros sin signo o naturales . . . . . . . . . . . . 151
5.3.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . 151
5.3.2. Caso Binario. Algoritmo de Suma y Desplazamiento . . 155
5.3.3. Mejora para saltar sobre ceros y unos consecutivos (bit-
scanning) . . . . . . . . . . . . . . . . . . . . . . . . . . 156
5.3.4. Recodificación del Multiplicador . . . . . . . . . . . . . 158
5.4. División de Enteros Sin Signo . . . . . . . . . . . . . . . . . . . 160
5.4.1. División Con Restauración . . . . . . . . . . . . . . . . 160
5.5. Algoritmos en Punto Flotante . . . . . . . . . . . . . . . . . . . 162
5.5.1. Suma y Resta . . . . . . . . . . . . . . . . . . . . . . . . 162
5.5.2. Multiplicación . . . . . . . . . . . . . . . . . . . . . . . 163
5.5.3. División . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
6.- Memorias 167

6.1. Ancho de Banda, Localidad y Jerarquı́a de Memoria . . . . . . 169
6.2. Organización de la Memoria . . . . . . . . . . . . . . . . . . . . 170
6.2.1. Memoria Entrelazada . . . . . . . . . . . . . . . . . . . 170
Rendimiento de Memorias Entrelazadas . . . . . . . . . 172
6.2.2. Memoria Asociativa . . . . . . . . . . . . . . . . . . . . 173
6.2.3. Memoria Caché . . . . . . . . . . . . . . . . . . . . . . . 176
Operación . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Organización . . . . . . . . . . . . . . . . . . . . . . . . 177
iv FUNDAMENTOS DE LOS COMPUTADORES
7.- Entrada/Salida 181

7.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
7.1.1. Organización . . . . . . . . . . . . . . . . . . . . . . . . 184
7.2. E/S Dirigida por Programa . . . . . . . . . . . . . . . . . . . . 186
7.3. Interrupciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
7.3.1. Clasificación de las Interrupciones . . . . . . . . . . . . 188
7.3.2. Operación . . . . . . . . . . . . . . . . . . . . . . . . . . 189
7.4. Acceso Directo a Memoria . . . . . . . . . . . . . . . . . . . . . 190
7.4.1. Organización . . . . . . . . . . . . . . . . . . . . . . . . 190
7.4.2. Operación . . . . . . . . . . . . . . . . . . . . . . . . . . 190
8.- Introducción a los Sistemas Operativos 193

8.1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
8.1.1. Tareas que realiza un Sistema Operativo . . . . . . . . . 195
8.1.2. Evolución de los Sistemas Operativos . . . . . . . . . . 196
8.2. Administración y Planificación de Procesos . . . . . . . . . . . 197
8.2.1. Proceso . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
8.2.2. Estados de un Proceso . . . . . . . . . . . . . . . . . . . 198
8.2.3. Planificación . . . . . . . . . . . . . . . . . . . . . . . . 202
8.2.4. Operaciones sobre Procesos . . . . . . . . . . . . . . . . 203
8.3. Memoria Virtual . . . . . . . . . . . . . . . . . . . . . . . . . . 204
8.3.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
Apéndices 209
A. Sistemas de representación especiales 209

A.1. Códigos detectores/correctores de errores . . . . . . . . . . . . 209
A.1.1. Bit de paridad . . . . . . . . . . . . . . . . . . . . . . . 209
A.1.2. Códigos polinómicos . . . . . . . . . . . . . . . . . . . . 210
A.1.3. Código Hamming . . . . . . . . . . . . . . . . . . . . . . 210
A.2. Códigos de longitud variable . . . . . . . . . . . . . . . . . . . . 211
A.2.1. Código Huffman . . . . . . . . . . . . . . . . . . . . . . 211
A.3. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
B. Rendimiento de un computador 215

B.1. Ley de Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
B.1.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
B.1.2. Casos lı́mite . . . . . . . . . . . . . . . . . . . . . . . . . 217
ÍNDICE v
B.2. Observación de Moore . . . . . . . . . . . . . . . . . . . . . . . 218

B.3. Observación de Grosch . . . . . . . . . . . . . . . . . . . . . . . 219
B.3.1. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
B.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
C. Códigos completos para el i8086 223

C.1. Códigos completos . . . . . . . . . . . . . . . . . . . . . . . . . 223
D. Detalles de diseño de cache 229

D.1. Polı́ticas de Asignación . . . . . . . . . . . . . . . . . . . . . . . 229
D.1.1. Asignación directa . . . . . . . . . . . . . . . . . . . . . 229
D.1.2. Asignación completamente asociativa . . . . . . . . . . . 230
D.1.3. Asignación asociativa por conjuntos . . . . . . . . . . . 230
D.2. Reemplazo y Actualización . . . . . . . . . . . . . . . . . . . . 232
D.3. Rendimiento de memorias cachés . . . . . . . . . . . . . . . . . 234
D.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
E. Solución a las relaciones de problemas 249

E.1. Representación de la Información . . . . . . . . . . . . . . . . . 249
E.2. Procesador Central . . . . . . . . . . . . . . . . . . . . . . . . . 257
E.3. Sección de Control . . . . . . . . . . . . . . . . . . . . . . . . . 264
E.4. Sección de Procesamiento: Algoritmos
Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
Bibliografı́a 277
Índice de figuras
1.1. Máquina de Charles Babbage . . . . . . . . . . . . . . . . . . . 4

1.2. Máquina de von Neumann . . . . . . . . . . . . . . . . . . . . . 6
1.3. Representación de un Sistema . . . . . . . . . . . . . . . . . . . 11
1.4. Especificación e Implementación . . . . . . . . . . . . . . . . . 11
2.1. Recta real y comportamiento de la caracterı́stica . . . . . . . . 24
3.1. Unidades del computador . . . . . . . . . . . . . . . . . . . . . 41
3.2. Una posible Sección de Procesamiento . . . . . . . . . . . . . . 48
3.3. Esquema a alto nivel de una sección de control . . . . . . . . . 49
3.4. Ubicación de datos en memoria . . . . . . . . . . . . . . . . . . 56
4.1. Unidad de control cableada . . . . . . . . . . . . . . . . . . . . 74
4.2. Unidad de control microprogramada . . . . . . . . . . . . . . . 74
4.3. Una hipotética sección de procesamiento elemental . . . . . . . 76
4.4. Registro de control . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.5. Sección de control microprogramado inicial . . . . . . . . . . . 79
4.6. Sección de control microprogramado más detallada . . . . . . . 80
4.7. Formas de onda de las señales en el tiempo . . . . . . . . . . . 81
4.8. Esquema parcial de las conexiones de temporización . . . . . . 82
4.9. Sección de control con capacidad de salto . . . . . . . . . . . . 84
4.10. Sección de control completa . . . . . . . . . . . . . . . . . . . . 86
4.11. Sección de procesamiento elemental . . . . . . . . . . . . . . . . 91
4.12. Formas de onda de las señales de tiempo . . . . . . . . . . . . . 93
4.13. Esquema parcial de las conexiones de temporización . . . . . . 94
4.14. Diagrama de tiempos del ciclo máquina . . . . . . . . . . . . . 95
4.15. Decodificador de microfunción . . . . . . . . . . . . . . . . . . . 96
4.16. Ampliación de la ALU . . . . . . . . . . . . . . . . . . . . . . . 99
4.17. Procesador hipotético completo . . . . . . . . . . . . . . . . . . 101
4.18. Diagrama de flujo a nivel RTL para el procesador . . . . . . . . 105
4.19. Transformación a elementos de retardo . . . . . . . . . . . . . . 107
4.20. Señales de control con elementos de retardo . . . . . . . . . . . 109
vii
viii FUNDAMENTOS DE LOS COMPUTADORES
4.21. Contador de secuencias módulo k . . . . . . . . . . . . . . . . . 111

4.22. Unidad de control utilizando un contador de secuencias . . . . 111
4.23. Unidades de Proceso y de Control (Prob. 4) . . . . . . . . . . . 115
4.24. Unidades de Proceso y de Control del multiplicador . . . . . . 118
4.27. Procesador microprogramado (Prob. 8) . . . . . . . . . . . . . . 130
4.28. Unidades de Datos y de Control (Prob. 9) . . . . . . . . . . . . 134
4.29. Unidad de Control (Prob. 11) . . . . . . . . . . . . . . . . . . . 136
4.30. Formato de las instrucciones . . . . . . . . . . . . . . . . . . . . 137
4.31. Datapath (Prob. 12) . . . . . . . . . . . . . . . . . . . . . . . . 138
5.1. Semi-sumador . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
5.2. Sumador completo (de un bit) . . . . . . . . . . . . . . . . . . . 147
5.3. Sumador serie (de n bits) . . . . . . . . . . . . . . . . . . . . . 147
5.4. Sumador de acarreo propagado (de n bits) . . . . . . . . . . . . 148
5.5. Sumador de acarreo almacenado de 4 bits . . . . . . . . . . . . 150
5.6. Árbol de Wallace para nueve sumandos . . . . . . . . . . . . . 151
5.7. Ejemplo de multiplicación con lápiz y papel . . . . . . . . . . . 152
5.8. Mejora del algoritmo y su implementación . . . . . . . . . . . . 153
5.9. Implementación de la segunda mejora del algoritmo . . . . . . 154
5.10. Multiplicación binaria . . . . . . . . . . . . . . . . . . . . . . . 155
5.11. Implementación del algoritmo bit-scanning . . . . . . . . . . . . 159
5.12. Ejemplo del algoritmo de división con restauración . . . . . . . 161
5.13. Algoritmo de división con restauración . . . . . . . . . . . . . . 162
5.14. Implementación del algoritmo de división binario . . . . . . . . 163
6.1. Jerarquı́a de Memorias . . . . . . . . . . . . . . . . . . . . . . . 170
6.2. Memoria Entrelazada de Orden Superior . . . . . . . . . . . . . 171
6.3. Memoria Entrelazada de Orden Inferior . . . . . . . . . . . . . 171
6.4. Diagrama de Bloques de una Memoria Asociativa . . . . . . . . 175
6.5. Ubicación de la Memoria Caché . . . . . . . . . . . . . . . . . . 176
6.6. Estructura de una Memoria Caché . . . . . . . . . . . . . . . . 177
6.7. Contenidos de la Memoria del Ejemplo . . . . . . . . . . . . . . 178
7.1. Diagrama de bloques de un computador . . . . . . . . . . . . . 183
7.2. Esquema del computador con periféricos . . . . . . . . . . . . . 184
7.3. E/S Mapeada en E/S . . . . . . . . . . . . . . . . . . . . . . . 185
7.4. E/S Mapeada en Memoria . . . . . . . . . . . . . . . . . . . . . 187
7.5. Esquema del DMA . . . . . . . . . . . . . . . . . . . . . . . . . 190
8.1. Capas de un S.O. . . . . . . . . . . . . . . . . . . . . . . . . . . 195
ÍNDICE DE FIGURAS ix
8.2. S.O. Multitarea . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

8.3. Estados de un proceso . . . . . . . . . . . . . . . . . . . . . . . 200
8.4. Ejemplos de transición entre estados de un proceso . . . . . . . 201
8.5. Traducción de referencia virtual a real . . . . . . . . . . . . . . 206
8.6. Traducción paginada . . . . . . . . . . . . . . . . . . . . . . . . 207
A.1. Arbol de generación Huffman . . . . . . . . . . . . . . . . . . . 212
B.1. Casos Lı́mite de la Ley de Amdahl. . . . . . . . . . . . . . . . . 218

B.2. Observación de Moore para las CPUs de Intel . . . . . . . . . . 219
D.1. Asignación directa . . . . . . . . . . . . . . . . . . . . . . . . . 230

D.2. Asignación completamente asociativa . . . . . . . . . . . . . . . 231
D.3. Asignación asociativa por conjuntos . . . . . . . . . . . . . . . 232
E.1. Diagrama de Flujo del programa del problema 8 . . . . . . . . 261

E.2. Diagrama de Flujo del programa del problema 9 . . . . . . . . 262
E.3. Árbol de Wallace para seis sumandos . . . . . . . . . . . . . . . 273
E.4. Árbol de Wallace para tres sumandos . . . . . . . . . . . . . . . 274
Índice de tablas
2.1. Código de caracteres ASCII en octal . . . . . . . . . . . . . . . 27

2.2. Código EBCDIC completo . . . . . . . . . . . . . . . . . . . . . 28
3.1. Programa que se analiza y contenido de la memoria . . . . . . 66
4.1. Funciones de los conmutadores de control . . . . . . . . . . . . 78
4.2. Conjunto de instrucciones de la CPU . . . . . . . . . . . . . . . 88
4.3. Contenido de la memoria de microprograma . . . . . . . . . . . 89
4.4. Funciones de los conmutadores de control . . . . . . . . . . . . 90
4.5. Definición de microinstrucción codificada . . . . . . . . . . . . . 98
4.6. Definición final de microinstrucción . . . . . . . . . . . . . . . . 100
4.7. Repertorio de instrucciones . . . . . . . . . . . . . . . . . . . . 104
4.8. Puntos de control especificados (Prob. 4) . . . . . . . . . . . . . 114
4.9. Memoria de microprograma (Prob. 4) . . . . . . . . . . . . . . 116
4.10. Conjunto de instrucciones (Prob. 4) . . . . . . . . . . . . . . . 117
4.11. Puntos de control del multiplicador (Prob. 5) . . . . . . . . . . 119
4.13. Puntos de control (Prob. 6) . . . . . . . . . . . . . . . . . . . . 121
4.15. Banco de registros (Prob. 7) . . . . . . . . . . . . . . . . . . . . 124
4.16. Puntos de control de la sección de datos (Prob. 7) . . . . . . . 126
4.19. Conjunto de instrucciones del procesador (Prob. 8) . . . . . . . 131
4.20. Puntos de control del procesador (Prob. 8) . . . . . . . . . . . . 131
4.21. Descripción de los puntos de control de la CPU (Prob. 9) . . . 133
4.22. Subconjunto de instrucciones de la CPU (Prob. 9) . . . . . . . 133
4.24. Extensión del conjunto de instrucciones . . . . . . . . . . . . . 136
4.25. Puntos de control (Prob. 12) . . . . . . . . . . . . . . . . . . . 139
5.1. Tabla de verdad de la suma . . . . . . . . . . . . . . . . . . . . 144
xi
xii FUNDAMENTOS DE LOS COMPUTADORES
5.2. Operación a realizar en el algoritmo bit-scanning . . . . . . . . 158

5.3. Recodificación de los bits del multiplicador . . . . . . . . . . . 159
E.1. Contenido de la memoria . . . . . . . . . . . . . . . . . . . . . 263

E.2. Memoria de microprograma (Prob. 1, 2 y 3) . . . . . . . . . . . 265
E.3. Problema 4. Memoria de microprograma . . . . . . . . . . . . . 266
Prefacio
Parece que ya deja de sorprender la creciente omnipresencia de los ordena-

dores en todos los ámbitos de la sociedad. A nosotros nos sigue impresionando
la rapidı́sima evolución de los sistemas basados en computador, su creciente
potencia de cálculo capaz de resolver cada vez problemas de mayor compleji-
dad y su capacidad de simplificar y reducir el tiempo necesario para realizar
muchas tareas cotidianas. Pues bien, los fundamentos, conceptos y modos de
operación de estas máquinas tan comunes hoy en dı́a, son los que tratamos
de introducir y desentrañar en este texto. O con otras palabras, este libro
está orientado a aquellas personas que alguna vez se han preguntado “¿Cómo
es posible que los transistores y puertas lógicas que hay dentro de mi ordena-
dor me permitan editar un archivo o ejecutar un programa que he escrito en
Modula o en C?”, pregunta, que por otro lado, esperamos se hayan planteado
todos nuestros alumnos de asignaturas de introducción a los computadores
(Fundamentos de los Computadores, Introducción a los Computadores, ...).
Más particularmente, los contenidos de este libro nacen de los apuntes de-
sarrollados para la asignatura Fundamentos de los Computadores. Esta asigna-
tura se imparte en el primer curso de la ETSI de Telecomunicación de Málaga
durante el segundo cuatrimestre, a razón de dos horas por semana. A esas
alturas del año, los alumnos ya han cursado la asignatura de Electrónica Di-
gital 1 y Elementos de Programación, impartidas en el primer cuatrimestre.
Por tanto, en este libro queremos cubrir el desnivel semántico que existe en
un sistema computador entre los contenidos de estas dos asignaturas previas
(electrónica digital y lenguajes de alto nivel), contemplando el control micro-
programado y cableado, el lenguaje ensamblador y los sistemas operativos,
según desglosamos a continuación por temas.
El tema 1 introduce los primeros conceptos básicos y una descripción ini-
cial de la arquitectura de von Neumann. El tema 2 describe los convenios
comúnmente utilizados para representar números, caracteres e instrucciones
en el computador. A partir del tema 3 profundizamos en la arquitectura de
computadores siguiendo un esquema estructural, en el que el computador se
compone del procesador (tema 3), el cual engloba la sección de control (tema
xiv FUNDAMENTOS DE LOS COMPUTADORES
4) y de procesamiento (tema 5), jerarquı́a de memoria (tema 6) y unidad de

Entrada/Salida (tema 7). Por último, el tema 8 describe como los Sistemas
Operativos permiten gestionar toda la arquitectura, dando una visión global
del computador. En esta segunda edición se ha incluido material adicional en
algunos temas y varios apéndices nuevos para cubrir también los contenidos
de la asignatura que con el mismo nombre se imparte en segundo curso de la
ingenierı́a técnica de telecomunicación.
Hemos creı́do conveniente recoger en un único libro estos contenidos en el
orden y con la extensión con que se imparten en esta asignatura. De esta forma,
se facilita al alumno de primero el seguimiento de la asignatura, ahorrándole
en gran medida el tiempo necesario para consultar la extensa literatura que
cubre este campo e interpretar los distintos puntos de vista con que se tratan
los mismos conceptos en cada uno de los libros. De cualquier modo, el alumno
interesado siempre puede consultar la bibliografı́a propuesta al final del libro
cuando su curiosidad le demande una mayor profundidad en sus conocimientos
de arquitectura.
Por otro lado, hemos omitido en el libro la referencia a arquitecturas con-
cretas que pueden quedar obsoletas en poco tiempo. Por ejemplo, la arquitec-
tura PC (la más familiar al alumno) del curso en que empezamos a impartir
esta asignatura (94/95), contenı́a probablemente un Pentium a 75Mhz con 3.1
millones de transistores, cache L1 de 8Kbytes de instrucciones y otros tantos
de datos, 16Mbytes de RAM FPM en módulos SIMM, 800 Mbytes de disco
duro IDE-ATA, por citar algunos números y estándares. Han pasado seis años
y para el curso que llaman del nuevo milenio ya disponemos de un Pentium4
con 42 millones de transistores, cache de más 256K, 128Mbytes de SDRAM,
DDR o RDRAM en módulos DIMM o RIMM y más de 20Gbytes de disco duro
Ultra-DMA ATA-100. Aunque pensamos actualizar este texto cada dos años,
hemos preferido reflejar en el libro sólo los aspectos de la arquitectura más in-
variantes en el tiempo (arquitectura del conjunto de instrucciones, estrategias
de control, algoritmos aritméticos, entrelazamiento de memoria, cache, inte-
rrupciones, DMA, etc.) que serán completados con ejemplos de arquitecturas
actuales durante cada clase.
Evidentemente, otra fuente de información actualizada es la WEB. Por
ello, mantenemos desde el año 96 páginas de las asignaturas:
http://www.ac.uma.es/academia/educacion/cursos/FundCompTel/
http://www.ac.uma.es/academia/educacion/cursos/FundCompST/
con apuntes, formulario de consulta/tutorı́a on-line, enlaces a páginas de in-
Prefacio xv
terés para completar conocimientos de arquitectura y otras noticias, como

notas de los exámenes, aportaciones de alumnos, etc., que esperamos sea de
utilidad y también motive al alumno a familiarizarse con su ordenador perso-
nal.
En último lugar, aunque no menos importante, queremos agradecer la co-
laboración de los miembros del Departamento de Arquitectura de Computa-
dores, en particular a José Marı́a González, por sus aportaciones y revisiones,
a Oscar Plata, por administrar el servidor web del departamento, y a Emilio
L. Zapata que fue quien nos enseñó arquitectura de computadores cuando éra-
mos nosotros los alumnos. Tampoco olvidamos las aportaciones de nuestros
alumnos, que nos han señalado las erratas y nos han ayudado a detectar los as-
pectos que necesitaban una explicación más detallada mediante sus cuestiones
y comentarios en clase. A ellos dirigimos y dedicamos este texto.
Los Autores
1
Introducción a los
Computadores
OBJETIVOS
Describir las caracterı́sticas básicas de los computadores del tipo von

Neumann
Proporcionar una perspectiva histórica
CAPÍTULO 1: INTRODUCCIÓN A LOS COMPUTADORES 3
1.1. NATURALEZA DE LOS COMPUTADORES
Empecemos esta introducción a la arquitectura de computadores recordando

dos definiciones básicas:
Computador: Sistema (conjunto de elementos interrelacionados) al que se
le suministran datos y nos aporta unos resultados acordes con la resolu-
ción de un determinado problema. Luego el objetivo del computador es
resolver problemas. Para ello ejecuta programas de forma rápida, eficaz
y cómoda.
Programa: Secuencia de instrucciones que resuelven el problema mencionado
en la definición anterior.
Para resolver problemas mediante programas también se utilizan al-
gunas herramientas:
Sistema Operativo (S.O.): facilitan la gestión de los recursos.
Compiladores de lenguajes de alto nivel.
1.2. ANTECEDENTES HISTÓRICOS
Desde tiempos muy antiguos el hombre ha necesitado hacer cálculos. Para ello
se ha buscado máquinas que lo ayudasen, como el ábaco, de origen oriental,
perfeccionado por los griegos; las Hileras de John Napier, que facilitaban la
multiplicación y la división; las Reglas de Cálculo, para calcular funciones
trigonométricas, exponenciales y logaritmos; etc.
1.2.1. Progresos mecánicos

A partir del siglo XVII se realizan progresos mecánicos en los sistemas de
cálculo. Aparecen las calculadoras mecánicas por varios motivos: investigación,
y principalmente económicos, para el cálculo de tablas astronómicas (útiles en
navegación) y para recaudar impuestos.
En 1623, W. Shickard (astrónomo amigo de Kepler) construye la primera
calculadora, basada en ruedas dentadas y capaz de sumar y multiplicar.
En 1642, B. Pascal, a los 19 años de edad construye una máquina que
suma y resta. Querı́a ayudar a su padre que era recaudador de impuestos.
En 1671, Leibnitz mejora la máquina de Pascal, diseñando la multipli-
cación por iteraciones. Ahora la nueva máquina suma, resta, multiplica
y divide. Realiza algunas aportaciones importantes:
• consigue cierto avance en la mecánica de precisión
4 FUNDAMENTOS DE LOS COMPUTADORES
• intuye que la máquina trabajará mejor con números binarios. (Esta

idea la retoma Boole para elaborar la Lógica de Boole en 1854, y
posteriormente Claude Shannon para sentar las bases de la Con-
mutación en 1937).
En 1820, Charles Babbage, realiza el progreso más importante: construye
en parte la máquina analı́tica. Será el primer computador digital de
propósito general. Caracterı́sticas de esta máquina:
• trabaja con aritmética de 50 dı́gitos decimales
• consigue velocidades de un segundo para sumar y restar y un minuto
para multiplicar y dividir
• trabaja con tarjetas perforadas para indicar las operaciones a rea-
lizar y las variables (programa externo).
• la estructura de su máquina se aprecia en la figura 1.1.
The Mill The Store

Datos OUT
(ALU) (Memoria)
Instrucciones Datos
Tarjetas de Tarjetas de
Operaciones Variables
Programa
Figura 1.1: Máquina de Charles Babbage
En 1880, Herman Holleritz, crea una máquina capaz de hacer estadı́sticas

sobre censos.
1.2.2. Progresos electromecánicos. Relés

En 1914, Leonardo Torres Quevedo, con tecnologı́a electromecánica di-
seña los esquemas de una calculadora digital de propósito general. Em-
plea representación en coma flotante.
En 1938, G. Stibitz, construye una máquina denominada Model I que
trabaja con números complejos, para realizar cálculos balı́sticos. Fue el

primer sistema con terminales remotos. Uno de sus sucesores, el Model
V, consta de dos procesadores y un total de 9000 relés. El Model VI
es gestionado por uno de los primeros sistemas operativos (proceso por
lotes -batch-).
En 1941, K. Zuse (Alemán) construye las máquinas Z1, Z2 y Z3. Esta
última es de propósito general con 2600 relés. El programa sigue siendo
externo.
En 1942, Atanasoff, fı́sico de la universidad de Iowa, construyó una
máquina de propósito general con tubos de vacı́o (conmutador electró-
nico). Realmente construyó un prototipo de máquina para el cálculo de
ecuaciones diferenciales. Por culpa de la guerra no terminó la máquina,
pero es considerado el inventor del ordenador.
1.2.3. Progresos electrónicos

En 1943, Mauchly y Eckert construyeron el ENIAC (Electronic Numeric
Integrator and Calculator). Fue considerado el primer computador di-
gital electrónico hasta el 1973. Su máquina estaba orientada a resolver
ecuaciones diferenciales y tablas balı́sticas.
Caracterı́sticas:
• 18000 tubos de vacı́o
• Consume 150 Kw
• Dimensiones: 30m de largo por 2.5m de alto
• Tenı́a 20 registros de 10 dı́gitos decimales
• Trabajaba con aritmética en punto fijo
• Velocidad: 200 µs para sumar, 2.8 ms para multiplicar y 6 ms para
dividir
• Introducción de datos mediante tarjetas perforadas
• La secuencia de operaciones se establecı́a mediante un conexionado
manual entre elementos, y por las posiciones de ciertos interrupto-
res. Introducir o modificar programas era muy tedioso.
En 1945, John von Neumann entra en el proyecto ENIAC. Será el encar-
gado de facilitar la programación del ENIAC. Conocı́a bien el trabajo
de Babbage y su máquina analı́tica. Aporta una idea innovadora: Alma-
cenar en una memoria rápida datos e instrucciones, y ası́ modificar el
programa consistirı́a sencillamente en modificar las instrucciones alma-
cenadas en memoria.
Diseña el EDVAC (Electronic Discrete Variable Automatic Compu-
ter). Esta máquina tiene más memoria pero es más lenta. Utiliza 44 bits
en punto fijo. Las instrucciones son de cuatro direcciones y tiene dos uni-
dades aritméticas. Sin embargo no fue la primera máquina con programa
almacenado.
En 1946, Maurice Wilkes, de la universidad de Cambridge comienza
el EDSAC (Electronic Delay Storage Automatic Calculator). Acaba en
1949 (tres años antes que el EDVAC).
En 1946 von Neumann entra en el Institute for Advanced Study (IAS
de Princeton). Con subvención militar construye el IAS. Algunas de sus
caracterı́sticas son:
• Dimensiones 2.4×2.4×0.6 m
• Memoria de 1024 palabras de 40 bits
1.3. ARQUITECTURA DE VON NEUMANN
La mayorı́a de los computadores se han construido siguiendo la arquitectura

de la máquina de von Neumann.
1. ESTRUCTURA (figura 1.2):
Unidad de
Control
Entrada ALU Salida
Datos Control
Datos
Memoria
Instrucciones
Figura 1.2: Máquina de von Neumann
a) Entrada.- Unidad que transmite instrucciones y datos del exterior

a la memoria (pasando por la ALU).
b) Memoria.- Unidad que almacena instrucciones y datos, ası́ como los

resultados parciales y finales de los programas.
c) A.L.U.- Unidad que realiza las operaciones aritmético-lógicas (su-
ma, multiplicación, OR, con datos de memoria). Tiene registros
para almacenar operandos: RALU.
d) Unidad de Control.- Interpreta las instrucciones y coordina el resto
del sistema.
e) Salida.- Transmite los resultados al exterior.
2. ARQUITECTURA:
a) Una sola memoria direccionada secuencialmente. La memoria tie-

ne una estructura lineal (vector de palabras direccionables). Es el
cuello de botella del sistema.
b) No hay distinción explı́cita entre instrucciones y datos. Los datos
no tienen ningún significado explı́cito.
c) El procesamiento es totalmente secuencial. Las fases de ejecución de
las instrucciones son secuenciales (sólo hay una unidad de control).
d) Hay instrucciones que permiten la ruptura de secuencia (es decir,
se permiten los saltos en el programa).
3. FUNCIONAMIENTO:
El objetivo del procesador es ejecutar instrucciones. Las instruccio-
nes son órdenes elementales (instrucciones máquina). Partimos de un
programa máquina (conjunto de instrucciones máquina) en memoria y
veremos cómo se ejecuta. Como las instrucciones están en memoria acce-
demos a ellas mediante direcciones. Una vez que conocemos la dirección
de la siguiente instrucción a ejecutar, las fases son las siguientes:
a) Búsqueda de la instrucción (fetch).

b) Decodificación.
c) Cálculo de la dirección de los operandos.
d) Búsqueda de los operandos.
e) Ejecución (realiza la operación y almacena el resultado).
Cada instrucción máquina debe especificar:
a) La operación a realizar en el Código de Operación (C.O.)

b) Información para calcular las direcciones de los operandos y dónde
se guarda el resultado (Modos de Direccionamiento).
c) Información de la dirección de la próxima instrucción a ejecutar.
4. DEFINICIONES:
- RALU: ALU + Registros.
- PROCESADOR: U.C. + RALU + lógica adicional para interconec-
tar todos los elementos.
- MICROPROCESADOR: procesador integrado en una pastilla de
silicio (chip).
1.4. GENERACIONES DE COMPUTADORES
Se presentará la evolución de los computadores agrupándolos en generaciones

según la tecnologı́a de fabricación.
Primera Generación: válvulas.
Segunda Generación: Transistores (TRT) discretos.
Tercera Generación: Small Scale Integration o SSI (<100 TRT’s) - Me-
dium SI o MSI (<3000 TRT’s).
Cuarta Generación: Large SI o LSI (<30.000 TRT’s) - Very Large SI o
VLSI (cientos de miles).
Quinta Generación: Inteligencia Artificial. Lenguajes de programación
lógicos (Japón).
Sexta Generación: Computadores paralelos, vectoriales y superescalares.
1. GENERACIÓN 1.a (1938 - 1952)
Tecnologı́a: válvulas de vacı́o. Eran máquinas voluminosas, de alto
consumo, caras y de vida limitada.
Máquinas: ENIAC, EDVAC, EDSAC, UNIVAC I, IAS, y las comer-
ciales IBM 701, 704, 709.
Avances del equipo fı́sico: en la memoria se pasa de registros de
válvulas a núcleos de ferrita; en la memoria secundaria, de tarjetas
y cintas perforadas a tambores y cintas magnéticas. Además se
introduce el control de interrupciones.
Avances del equipo lógico: utilización de aritmética binaria, progra-
mación en ensamblador (para ayudar al programador).
2. GENERACIÓN 2.a (1953 - 1962)
Tecnologı́a: en 1948 se inventó el transistor en los laboratorios de la
Bell. Pero hasta 1954 no construyeron el TRADIC en la Bell, que fue
el primer computador transistorizado. Las ventajas del transistor
son que es más pequeño, el consumo es menor y más barato que las
válvulas. Con lo cual los computadores se hacen más asequibles.
Máquinas: UNIVAC 1107, BURROUGH D-805, PDP-5 de DEC, y

las cientı́ficas IBM 7070, 7090, 7094.
Avances del equipo fı́sico: se consolidan las memorias de ferrita.
Aparecen los canales de E/S.
Avances del equipo lógico: aparecen los lenguajes de alto nivel
(FORTRAN, COBOL, ALGOL, PL1). Se impone el procesamien-
to tipo batch o por lotes: ejecución automática y secuencial de los
programas de usuario, uno a uno.
3. GENERACIÓN 3.a (1963 - 1971)
Tecnologı́a: se integran los transistores y aparecen los Circuitos In-
tegrados (C.I.): SSI, MSI.
Máquinas: IBM 360. Aparecen las “Familias de Computadores”:
computadores de distinta potencia y precio pero con la misma ar-
quitectura y totalmente compatibles. Se produce una explosión de
los mini-computadores: recursos más limitados pero muy asequibles
(PDP-8, PDP-11).
Avances del equipo fı́sico: tarjetas de circuito impreso (PCB); me-
morias electrónicas sustituyen a las de ferrita; aparecen las memo-
rias cache; la CPU está basada en registros de propósito general.
Avances del equipo lógico: nuevos lenguajes de alto nivel (BASIC,
PASCAL); gran avance en el S.O.; aparece la multiprogramación.
4. GENERACIÓN 4.a (1972 - 1987)
Tecnologı́a: se incrementa la escala de integración (LSI, VLSI). Se
puede integrar en un chip todo un procesador. Los computadores
con microprocesador se llamaron microcomputadores.
Máquinas: se pueden distinguir 4 fases:
a) 1.a fase (1971 - 74): microprocesador de 4 bits, como el INTEL
4004 con 2300 TRT’s y LSI.
b) 2.a fase (1974 - 76): microprocesador de 8 bits, como el 8080 de
INTEL con 5000 TRT’s, el 6800 de Motorola con 6000 TRT’s,
o el Z80 de Zilog.
c) 3.a fase (1976 - 80): microprocesador de 16 bits, como el 8086
de INTEL (con 29000 TRT’s), el Z8000 de Zilog o el 68000 de
Motorola.
d) 4.a fase (1980 - 87): microprocesador de 32 bits, como el 80286
(con 134000 TRT’s), el 80386 (con 275000 TRT’s) de INTEL,
o el 68020 y el 68030 de Motorola.
Avances del equipo fı́sico: más integración de las memorias; los dis-
cos duros tienen más capacidad; aparecen los coprocesadores para

el tratamiento en punto flotante FPU y los gestores de memoria o
MMU.
Avances del equipo lógico: se normaliza el uso de la memoria vir-
tual; los S.O. permiten la multitarea y el multiproceso; se producen
avances en los lenguajes de alto nivel.
5. GENERACIÓN 5.a (desde 1988 hasta hoy)
Tecnologı́a: los modernos CI’s son hoy en dı́a capaces de integrar
más de 1 millón de TRT’s.
Máquinas: Distinguimos tres apartados:
a) Procesadores de altas prestaciones. Las familias de procesa-
dores siguen evolucionando: INTEL 1 : 486 (1.2, 25-100MHz),
Pentium (3.1, 60-233MHz), Pentium Pro (5.5, 150-200MHz),
PentiumII (7.5, 233-450MHz), PentiumIII (44, 450MHz-1.4GMHz),
Pentium M (144, 1.2-2GHz), Pentium 4 (108, 2-3.8GHz), y
otros (Pentium D, Pentium EE, Itanium II ...); AMD: K5, K6,
K6 3D, K6+ 3D, Athlon (K7), Athlon 64, Opteron; Procesa-
dores RISC: Power 4 y 5, Alpha 21064 - 21364, UltraSPARC,
R10000 - R16000, etc.
b) Supercomputadores de alta velocidad. Aparecen porque se bus-
caba más velocidad. Se emplean fundamentalmente para pro-
cesado de imagen, control de robots, simulación, etc. Para au-
mentar la velocidad se incrementa el HW, se utilizan más mi-
croprocesadores, dando lugar a sistemas multiprocesador y al
paralelismo, y empleando la “segmentación” y las máquinas
vectoriales.
c) Computadores de funciones inteligentes. Inicialmente la com-
putación se realizaba sobre datos. Posteriormente se realizó so-
bre información (conjunto de datos relacionados). Pero ahora,
lo que se pretende con este tipo de máquinas es la computación
sobre el conocimiento (es decir, cuando a la información se le
da valor semántico). Se quieren diseñar computadores capaces
de tomar decisiones inteligentes en función de un conjunto de
conocimientos (base de conocimientos). Aparecen los sistemas
expertos, como el MYCIN, que se emplea para diagnósticos de
enfermedades infecciosas a partir de determinados sı́ntomas.
1
Los dos números entre parantesis indican los millones de transistores y el rango de
frecuencias de trabajo de esos procesadores.
1.5. NIVELES DE DESCRIPCIÓN
Se define un sistema como una combinación de elementos que actúa conjunta-

mente y cumplen con un determinado objetivo o función. Podemos represen-
tarlo según se ve en la figura 1.3, donde z = F (x), y llamamos a F función de
transferencia.
X Sistema Z
Figura 1.3: Representación de un Sistema
El comportamiento de entrada/salida es el conjunto de relaciones que el

sistema establece entre la entrada y la salida. Podemos hablar de sistema fı́sico,
sistema digital, sistema analógico, sistema de telecomunicación, ...
1.5.1. Especificación e implementación de un sistema

Podemos distinguir entre:
La especificación de un sistema que consiste en la descripción funcional
de lo que hace el sistema a alto nivel.
La implementación del sistema que es la realización del sistema, es decir,
la construcción del sistema satisfaciéndose requisitos tales como presta-
ciones y coste.
El paso de la especificación a la realización (implementación) se consigue
mediante la sı́ntesis o diseño. El paso contrario, como vemos en la figura 1.4,
es el análisis.
ANALISIS
ESPECIFICACION IMPLEMENTACION
SINTESIS
Figura 1.4: Especificación e Implementación

Si nos centramos en un sistema particular como puede ser un sistema de

computadores, lo podemos describir también siguiendo esas dos alternativas:
1. Dando una descripción funcional del microprocesador. Esta descripción
es la que viene en las hojas de datos comerciales, que cuentan cómo
funciona, qué instrucciones máquina puede ejecutar (ISP), cómo se ges-
tionan las interrupciones, etc.
2. Dando una descripción lógica del microprocesador. Consiste en describir
el circuito a nivel de puertas. Ésta es una información que suele estar
reservada por los fabricantes. Es en definitiva la implementación.
Conociendo la descripción funcional, se sabe qué hace el computador y
cómo funciona, pero no cómo está construido (implementado). Por el contra-
rio, conociendo la descripción lógica se sabe cómo está hecho, pero es muy
difı́cil determinar su funcionamiento y el modo de operación a partir de esa
información.
Entre estos dos niveles de descripción extremos de un microprocesador, se
puede considerar otro, el denominado nivel de transferencia de registros, RTL.
Mediante este nivel de descripción intermedio, se especifican los registros y
cómo se transfiere información entre ellos: cómo pasa la información por la
ALU, cómo se guarda en memoria, etc. De esta forma, sabremos un poco de
la implementación (a alto nivel) y, por otro lado, será más sencillo determinar
el funcionamiento del computador a partir de la descripción RTL. Es el nivel
que básicamente utilizaremos en esta asignatura.
SINOPSIS
Resumiendo, este tema ha servido tanto para introducir y repasar algunos

conceptos básicos, como para recorrer las etapas cubiertas en la evolución de
los sistemas de cálculo y computación. También hemos hecho especial hinca-
pié en la arquitectura de von Neumann debido a que es la base sobre la que se
han construido los computadores modernos. Como apunte final, subrayar la
vertiginosa evolución del campo del que trata esta asignatura: por poner sólo
un ejemplo, comparando el ENIAC con un PentiumIII a 500MHz, el tiempo
necesario para realizar una suma se ha reducido en 5 ordenes de magnitud en
apenas 50 años.
2
Representación de la
Información
OBJETIVOS
Estudiar los modos de representación de enteros y flotantes

Entender el formato de las instrucciones y los modos de direccionamiento
CAPÍTULO 2: REPRESENTACIÓN DE LA INFORMACIÓN 15
2.1. CLASIFICACIÓN DE LA INFORMACIÓN
El ordenador para resolver problemas ejecuta programas en los que se procesa

información. Para representar información normalmente se utiliza un alfabeto
de sı́mbolos (el alfabeto de las letras, los dı́gitos, las notas musicales...). El
alfabeto del ordenador solo tiene dos sı́mbolos: 0 y 1.
Las razones de que sólo se utilicen dos sı́mbolos son:
1. Es más fácil trabajar con dispositivos de dos estados, que con dispositivos
de diez estados. Por ejemplo: los relés, las válvulas y los TRT’s. Aunque
los TRT’s tienen 4 modos de funcionamiento, tan sólo 2 de ellos (corte
y saturación) son los que se emplean en electrónica digital. Un estado
representa el 0 y el otro el 1. Además, la conmutación entre estos dos
estados ha de ser lo más rápida posible (en ruedas dentadas con 10
estados estas conmutaciones eran muy lentas).
2. El sistema binario tiene casi la mejor eficiencia de almacenamiento de la
información.
Sea X codificado como un vector de dı́gitos
xn , xn−1 , ..., x1 , x0 , x−1 , ..., x−m ,
teniendo en cuenta que:

a) b es la base o radix.
b) El rango
!n de cada dı́gito va desde 0 a b-1.
c) |x| = −m xi b .i
d) Con n dı́gitos, se pueden representar N = b n números posibles.

e) Sea la magnitud E = nb = (ln N/ ln b) · b, que expresa el coste
asociado a almacenar bn valores distintos usando una base b y un
vector de n dı́gitos.
El valor que minimiza E, es decir, la base que fuerza dE/db = 0 y
d2 E/d2 b > 0, es b = e. Como la base ha de ser un número entero y
2 < e < 3, la base de los computadores digitales es 2.
Los inconvenientes de esta elección son básicamente:
1. Cada vez que queremos comunicar algo al computador es necesario rea-
lizar una conversión al código binario, y viceversa.
2. A veces los números binarios tienen una longitud excesiva, y las secuen-
cias pueden ser muy largas y engorrosas.
En un computador la información se representa por medio de secuencias
binarias, las cuales se organizan en “palabras”. Se define una “palabra” como
la cantidad de información codificada mediante n dı́gitos binarios, donde n es

determinado atendiendo a diversas consideraciones (rango de representación,
coste HW, etc...). Los valores tı́picos de n son:
n=4 ⇒ nibble
n=8 ⇒ byte
n=16 ⇒ word
n=32 ⇒ double word
Como vemos, normalmente se utilizan palabras con n potencia de 2. Los com-
putadores actuales tienen tamaños de palabra múltiplo de 8: 8, 16, 32 y 64
bits.
Pues bien, como hemos dicho, vamos a codificar la información mediante
cadenas de 1’s y 0’s. Pero la codificación se hará de distinta forma en función
de qué tipo de información vayamos a codificar. Por tanto, clasificaremos los
tipos de información que necesitamos representar en el computador según el
siguiente esquema:
⎧
⎪
⎪ Instrucciones
⎧ (Información de Control)
⎪ No Numéricos
⎧ (caracteres & alfanuméricos)
⎪
⎪ ⎪
⎪
⎪ ⎪
⎪
⎪
⎨ ⎪
⎪ ⎪ Posicionales
⎪
⎨ ⎪
⎪ Enteros
⎪
⎨ No Posicionales
⎪ Datos
⎪
⎪
⎪ ⎪
⎪ Numéricos &
⎪ ⎪ ⎪
⎪
⎪ ⎪
⎪ ⎪
⎪ Punto Fijo
⎪
⎩ ⎪
⎩ ⎩ Reales
⎪
Punto Flotante
y en los siguientes apartados iremos viendo, para cada uno de los tipos de
información, qué estrategia de codificación utilizamos normalmente.
Pero antes de entrar en el estudio de la representación de los datos y de
las instrucciones, nos vamos a plantear una cuestión que se presenta inevita-
blemente, debido a que tanto los datos como las instrucciones se representan
mediante cadenas de unos y ceros: desde que von Neumann almacenó tanto
datos como instrucciones en memoria, estos dos tipos de información son in-
distinguibles entre sı́ (es decir, si elegimos una palabra aleatoriamente de
la memoria no podemos decir si es un dato o una instrucción). Algunos di-
señadores argumentaban que se deberı́a añadir una etiqueta (secuencia de bits
especial) para distinguir los datos de las instrucciones y evitar cosas como
intentar ejecutar un dato. Pero añadir etiquetas incrementa el tamaño de la
memoria, el coste HW y realmente es innecesario. Si el procesador esta co-
rrectamente diseñado y el programa a ejecutar se inicializa adecuadamente y
está bien programado, un registro, llamado Contador de Programa (PC), per-
mite identificar qué posiciones de memoria contienen una instrucción y cuáles

un dato.
2.2. REPRESENTACIÓN DE LOS DATOS
2.2.1. Datos Numéricos

Los factores a tener en cuenta para representar números son:
1. el tipo de los números a representar (enteros, reales, etc)
2. el rango de números representables
3. la precisión del dato numérico (n.o de números para un rango dado)
4. el coste HW requerido para almacenar y procesar los números a repre-
sentar.
2.2.2. Enteros
1. Posicionales, ponderados o pesados.
✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿✿
Son los utilizados por la gran mayorı́a de computadores. Un número
se representa como un vector o secuencia de dı́gitos, donde cada uno
tiene un peso de acuerdo con la posición que ocupa. Si la base de repre-
sentación es b, el rango de cada dı́gito va de 0 a b − 1. Como hemos dicho
anteriormente, en los sistemas de computadores se emplea la base b = 2.
O sea, si el número x se codifica mediante el siguiente vector de
dı́gitos:
xn , xn−1 , ..., x1 , x0 , x−1 , ..., x−m
su valor es
n
'
|x| = xi bi (2.1)
−m
En principio hablaremos, en esta sección, únicamente de números

enteros, por lo tanto no encontraremos potencias negativas en el suma-
torio de la última ecuación (es decir el rango de posibles valores de i es
i = {0, 1, 2, ..., n}). Los números fraccionarios (reales) sı́ tienen potencias
negativas de la base en el sumatorio.
Con este tipo de representación, el problema es que leer y escribir
largas cadenas de 1’s y 0’s es engorroso y una tarea propensa a cometer
errores. Como solución, se suele utilizar la base octal (b = 8) y la base
hexadecimal (b = 16). Como las dos bases son potencias de dos, las
conversiones son triviales.
Dentro de los números enteros tendremos que distinguir a su vez

entre los números positivos y negativos.
Si sólo representamos enteros positivos, con n bits representaremos
desde el 0 al 2n − 1.
Para codificar los números enteros negativos, hemos de tener en
cuenta algunas consideraciones:
a) el intervalo de números positivos deberı́a ser igual al intervalo
de números negativos para un n dado
b) sea fácil detectar el signo por un simple test HW
c) sea también fácil detectar el 0
d) el código resultante de la codificación ha de dar lugar a una
implementación sencilla a la hora de realizar las operaciones
aritméticas básicas.
Para dar respuesta a estas consideraciones, aparecen tres sistemas
de numeración posicionales que permiten la representación de nú-
meros negativos:
a) Signo/Magnitud
Llamaremos bit de signo al bit más significativo (el primer bit
por la izquierda). En función de su valor determinamos el signo
del número:
⇒ 0 → número positivo
⇒ 1 → número negativo
para n bits, el intervalo de representación va de −(2 n−1 − 1) a
2n−1 − 1
como ventajas, cumple los requisitos (a) y (b).
como gran inconveniente, da lugar a una representación dual
del 0, con lo cual se desperdicia un número y complica la detec-
ción del 0 (requisito (c)). Además no se verifica el requisito (d),
porque la suma no es tan evidente como veremos en el tema
5. Podemos adelantar que en el caso de la suma de números
de distinto signo, será necesaria la implementación HW de un
restador y de un comparador de magnitudes para determinar
el signo del resultado.
Como conclusión, esta representación ampliamente utilizada en los
computadores de la 3.a Generación, en la actualidad no se utiliza.
Ahora se emplea únicamente para la codificación de números en
punto flotante.
b) Complemento a 1: (C1)
Es un caso particular del complemento a la base menos 1, en
el que la base es 2. Representaremos un número de n bits en
complemento a uno siguiendo la siguiente fórmula:
&
x Si x ≥ 0,
C1(x) = n (2.2)
(2 − 1) − |x| Si x ≤ 0.
operación que resulta equivalente a complementar los bits de x
cuando x es negativo.
como ventajas, cumple el requisito (a), puesto que la cantidad
de números positivos es igual a la de números negativos. Es
decir, el rango va desde el −(2n−1 − 1) al 2n−1 − 1. Además,
cumple el requisito (b), porque es fácil detectar el signo y cum-
ple el requisito (d), porque facilita las operaciones (restar no
es más que complementar el sustraendo y sumar, es decir, el
algoritmo y el HW para sumar y restar es común)
como inconveniente, da lugar a una representación dual del 0
(tanto el 00000 como el 11111), por lo que no cumple el requisito
(c).
c) Complemento a 2: (C2)
Es un caso particular del complemento a la base, en el que la
base es 2. Representaremos un número de n bits en comple-
mento a dos siguiendo la siguiente fórmula:
&
x Si x ≥ 0,
C2(x) = (2.3)
2n − |x| Si x < 0.
operación que resulta equivalente a complementar los bits de x
y sumar 1 (C2(x) = C1(x) + 1) si x < 0.
como ventajas, cumple el requisito (a), puesto que la cantidad
de números positivos es prácticamente igual a la de números
negativos. Es decir, el rango va desde el −2 n−1 al 2n−1 − 1.
Además, cumple el requisito (b), porque es fácil detectar el sig-
no y cumple el requisito (c), porque no tiene representación
dual del 0, ası́ que es fácil detectarlo. Cumple ası́ mismo el re-
quisito (d) como veremos en el tema de algoritmos aritméticos.
como pequeño inconveniente respecto al C1, se puede argumen-
tar que complementar a 2 es más costoso que complementar a
1 ya que hay que realizar una suma adicional. Sin embargo, el
HW que implementa el C2 se puede construir sin ningún su-

mador y por otra parte, normalmente no es necesario construir
el HW para el C2 explı́citamente. Por ejemplo, para realizar la
resta, debemos sumar el C2 del sustraendo, pero en la imple-
mentación sumamos el C1 del sustraendo poniendo además a
1 el carry de entrada del sumador, con lo que la operación es
totalmente equivalente. Es decir:
A − B ≡ A + C2(B) ≡ A + C1(B) + (Carry in = 1)
Como conclusión, podemos decir que es la representación más uti-

lizada a la hora de representar números enteros negativos.
2. ✿✿✿ Posicionales 2
No✿✿✿✿✿✿✿✿✿✿✿✿✿
a) BCD (decimal codificado en binario natural)
Cada dı́gito decimal se codifica por 4 bits binarios (16 valores po-
sibles). Ello da lugar a V16/10 = 2.9 × 1010 códigos BCD’s posibles.
El código BCD más utilizado es el BCD natural, en el que la co-
dificación de cada dı́gito es equivalente a la codificación binaria.
Podrı́amos decir que cada dı́gito se expresa mediante un nibble en
el que se utilizan los pesos 8,4,2,1; pero además la posición del nib-
ble está pesada según potencias de 10.
La ventaja de este tipo de representación, es que facilita al
hombre la comprensión de los números representados. Además,
la conversión de números decimales a BCD es más rápida que
la conversión a binario.
Como gran inconveniente, la eficiencia de almacenamiento de-
crece en 10/16 veces respecto de la eficiencia de almacenamien-
to en binario. Ello es debido a que de los posibles 16 números
que podemos representar en binario con 4 bits, en BCD sólo
representamos 10 (del 0 al 9). Además, con este tipo de co-
dificación se ocupa más memoria, y las operaciones son más
lentas.
Como conclusión, este tipo de codificación es beneficiosa cuando
las operaciones de entrada/salida dominan a las de computación
(aunque no suele ser ası́).
b) EXCESO A 3
2
En un sentido estricto los códigos comentados bajo este epı́grafe no son posicionales ya
que el valor del número no se puede calcular directamente a partir de la ecuación 2.1
Es otro BCD construido a partir del BCD natural al que se le suma

3 a cada dı́gito. Como ventaja, es más cómodo hacer operaciones
aritméticas, ya que es autocomplementario, puesto que la represen-
tación negativa es igual al C9 del número decimal que representa.
c) AIKEN
Es otro código BCD en el que los pesos dentro de cada nibble son
1, 2, 4, 2 en vez de 1, 2, 4, 8. Es autocomplementario.
d) GRAY
No es un código BCD. También se conoce con el nombre de binario
reflejado. Los códigos de dos enteros consecutivos difieren en un
sólo bit. Además es cı́clico.
2.2.3. Reales
1. Punto Fijo
✿✿✿✿✿✿✿✿✿✿✿
Una posibilidad, a la hora de intentar representar números con deci-
males, puede consistir en colocar un punto en algún lugar de la cadena
de unos y ceros que va a representar nuestro número real. Una vez colo-
cado el punto en una determinada posición ya no se puede modificar, ya
que esa decisión se toma normalmente durante el diseño de la máquina.
A la derecha del punto las potencias de la base son negativas.
Como ventaja, en este sistema de representación los requerimientos
HW son relativamente simples.
Como inconveniente principal, tanto el rango de valores como la
precisión quedan limitados, y el programador o analista numérico
que quiera resolver un problema, tendrá que escalar los números de
entrada y los resultados intermedios para no salirse del intervalo o
rango de valores representables.
Los números enteros se pueden ver como un caso particular de la no-
tación en punto fijo, es decir, como números en punto fijo, pero colocando
el punto detrás del bit menos significativo.
2. ✿✿✿✿✿✿
Punto✿✿✿✿✿✿✿✿✿✿
Flotante
Como hemos dicho, en la aritmética de punto fijo podemos perder
precisión y dı́gitos significativos con facilidad. Para solucionarlo se pro-
pone la notación cientı́fica o de punto flotante. Consiste en representar
el número mediante una mantisa, una base y un exponente. Puesto que
la base es conocida y constante, basta con almacenar la mantisa y el
exponente.
En esta representación, el punto decimal “flota”, es decir, cambia de

posición dependiendo del exponente. Como en el computador la repre-
sentación ha de ser única, se requiere una representación normalizada.
En principio podemos considerar la representación normalizada como
aquella que sitúa el dı́gito más significativo distinto de cero a la derecha
del punto.
Antes de entrar en detalle sobre distintos tipos de representación en
punto flotante, y para dar una perspectiva histórica sobre este aspecto,
veamos que pensaba von Neumann acerca de la representación en punto
flotante: von Neumann decı́a que los propósitos del punto flotante pa-
recı́an ser, por un lado, retener tantos dı́gitos significativos como fuera
posible y, por otro, obviar los factores de escala. Pero según su pun-
to de vista, opinaba que estas ventajas eran ilusorias por las siguientes
razones:
el tiempo que lleva programar el escalado es menor que el tiempo
para programar la operación completa (se puede decir que despre-
ciable en aquella época).
además, en vez de reservar un campo para representar el exponente,
serı́a conveniente utilizar los bits de ese campo para ampliar la
mantisa, consiguiendo ası́ más precisión.
los números flotantes no sólo ocuparı́an más memoria, sino que
además necesitan una lógica (HW) más costosa y compleja.
La experiencia y la historia han demostrado que von Neumann se
equivocó. Hay que tener en cuenta que para los antiguos diseñadores de
computadores era preferible ahorrar memoria y tiempo de ejecución a
ahorrar tiempo de programación.
Existe una gran cantidad de formatos en punto flotante, en cada uno
de los cuales se especifican el número de bits para la mantisa, el número
de bits para el exponente, la base, el convenio de normalización, etc.
Nosotros veremos dos posibilidades:
a) Formato IEEE 754
b) Formato del IBM/360
A) FORMATO PUNTO FLOTANTE IEEE 754

Hasta 1985 los formatos en punto flotante cambiaban de una familia
de computadoras a la siguiente. Ello daba lugar a gran cantidad de pro-
blemas para los analistas numéricos que no podı́an portar sus programas
de unas máquinas a otras, ası́ como para los arquitectos de computadores
que no sabı́an que formato implementar y mejorar. Para evitar estos pro-
blemas se adopta un formato estándar para números en punto flotante
de 32 y 64 bits, el denominado IE 3 754.
A-1) Formato IE 3 754 simple precisión (32 bits)
La palabra de 32 bits se organiza en los siguientes campos:
1 bit para el signo (S)
8 bits para la caracterı́stica (C)
23 bits para la mantisa (M)
Puesto que la base es 2, el número representado es:
N = (−1)S × (1.M ) × 2C−127
Donde:
(S) El bit de signo se interpreta como:
◃ S=0⇒N ≥0
◃ S=1⇒N ≤0
(M) Es la mantisa normalizada. Inicialmente se aplicó el convenio
de normalización de tipo. 0.1xxxx. En una mejora posterior se ar-
gumenta: en lugar de forzar un 1 a la derecha del punto decimal, lo
que hacemos es colocarlo a la izquierda del punto decimal (es decir,
en la forma 1.xxxx). Esta será la representación normalizada. Por
otro lado, como sabemos que el número está normalizado y que hay
un 1 en esa posición, éste no lo representamos. Es decir, como sa-
bemos que el número debe estar normalizado para representarlo, y
que si está normalizado seguro que hay un 1 a la izquierda del punto
¿para qué habrı́amos de desperdiciar un bit de la mantisa almace-
nando un 1 que siempre va a estar ahı́? Por tanto el 1 a la izquierda
del punto no se almacena explı́citamente en la representación, sino
que queda implı́cito en el convenio.
(C) La caracterı́stica representa el exponente en exceso 127. Es
decir, el exponente, E, se calcula como:
E = C − 127 ⇒ C = E + 127
Existen dos motivos para representar el exponente mediante una
notación en exceso, en lugar de utilizar una notación en C2 o alguna
otra que permita representar exponentes negativos:
• En primer lugar, mediante la representación del exponente en
exceso, la comparación de dos exponentes para decidir cual es
mayor de los dos se puede realizar mediante un sencillo com-
parador de enteros positivos. La comparación de exponentes es
una operación muy frecuente en aritmética flotante y el HW
que la implemente debe ser simple y rápido.
• En segundo lugar, también encontramos una cuestión semán-
tica para utilizar notación en exceso: a medida que el número va
haciéndose más pequeño, la caracterı́stica también va haciéndo-
se más pequeña. Como el 0 es el más pequeño, es el número
que ha de tener la caracterı́stica mı́nima. Utilizando una nota-
ción en exceso, la magnitud de la caracterı́stica decrece cuando
decrece la magnitud del número representado, como vemos en
la figura 2.1. Si utilizásemos una notación en C2 (por ejemplo)
para la caracterı́stica, la magnitud de la caracterı́stica decrece
cuando decrece la magnitud del número representado si éste es
mayor que uno, pero crece cuando el número es menor que uno.
0 ... 0.25 0.5 1 2 1.9999x2127

C=0 C=125C=126 C=127 C=128 C=254
Figura 2.1: Recta real y comportamiento de la caracterı́stica
De manera que el comportamiento de la caracterı́stica y del

exponente es el siguiente (suponiendo una mantisa 1.0):
C > 127 ⇒ E>0 ⇒ Número > 1

C = 127 ⇒ E=0 ⇒ Número = 1
C < 127 ⇒ E<0 ⇒ Número < 1
C =0 ⇒ −−− ⇒ Número = 0
Casos particulares
Para representar C tenemos 8 bits, es decir, podemos representar en
principio 256 (0-255) caracterı́sticas distintas. O, traducido a exponente,
desde -127 a 128. Sin embargo, reservamos C=0 y C=255 para casos
especiales:
⎧ ⎧ &
⎪ ⎨ S = 0 ⇒ +∞
⎪
⎪ M = 0
⎪
⎪
⎪ C = 255 S = 1 ⇒ −∞
⎨ ⎩
M ̸= 0 ⇒ NaN (Not a Number )
⎪
⎪ &
⎪
⎪
⎪ M =0⇒N =0
⎩ C=0
⎪
M ̸= 0 ⇒ N = (−1)S · 0.M · 2−126
Los valores NaN (la traducción literal serı́a “no un número”) apare-
√
cen cuando el resultado de una operación no es un número real ( −1,
00 , ln(−1), etc...). Por otro lado, el caso en que C = 0 y M ̸= 0 se utiliza
para representar números no normalizados o desnormalizados. Este caso
particular aparece para representar números con exponente menor que
-126. Luego aquellos números con C = 0 y M ̸= 0 son números con
exponente E=-126 y cuya mantisa no está normalizada, es decir, sin 1
oculto, o lo que es lo mismo, la mantisa es exactamente la almacenada.
Los números no normalizados se emplean para representar números muy
cercanos a 0.
A-2) Formato IE 3 754 doble precisión (64 bits)
El formato IE 3 754 de doble precisión utiliza una palabra de 64 bits
organizada en los siguientes campos:
11 bits para la caracterı́stica, (C), en exceso 1023
Luego el número representado sera:
N = (−1)S × (1.M ) × 2C−1023
B) FORMATO IBM/360
Es el formato implementado en el IBM/360. Se basa en una palabra
de 32 bits organizada en los siguientes campos:
7 bits para la caracterı́stica (C)
Pero ahora la base es 16, el exponente en exceso 64 y no existen

casos especiales. Por tanto, el número representado vendrá dado por la
siguiente expresión:
N = (−1)S × (0.M ) × 16C−64
Para que el exponente crezca o decrezca una unidad, los desplaza-
mientos serán de 4 bits. El número estará normalizado cuando el primer
dı́gito hexadecimal a la derecha de la coma sea distinto de 0. Ello
dará lugar a que desde el punto de vista binario (que será como se al-
macene finalmente el número), algunos números no estén normalizados,
porque puede haber hasta tres 0’s a la derecha de la coma. De esta forma
se pierde precisión. La ventaja de esta representación, es que el rango
representado aumenta.
2.2.4. Datos No Numéricos. Caracteres

El objetivo es codificar 26 letras mayúsculas y minúsculas, 10 dı́gitos, signos
de puntuación y algunos caracteres especiales (sı́mbolos matemáticos, letras
griegas..). También es necesario representar caracteres de control tales como
CR (Carriage Return), BS (Back Space), Del (Delete), etc, y caracteres de
transmisión como ACK (Acknowledge), NAK (No Acknowledge), EOT (End
Of Transmision), ETB (End of Transmision of Block), etc.
Para codificar estos caracteres, se emplean:
6 bits. Da lugar a 64 caracteres distintos. Son pocos.
7 bits. Da lugar a 128 caracteres. Uno de los códigos más estándares de 7
bits es el conocido como ASCII (American Standard Code for Informa-
tion Interchange). En la tabla 2.1 encontramos los 128 caracteres ASCII
con su codificación en octal.
8 bits. Da lugar a 256 caracteres. Un código de 8 bits definido por IBM
es el EBCDIC. En la tabla 2.2 tenemos el código EBCDIC completo. En
esta tabla los bits 0-3 son los más significativos (por ejemplo, la letra D
se codifica 1100 0100).
En muchas máquinas se extiende el ASCII a 8 bits, pero sólo son estándares
los primeros 128 caracteres.
2.3. REPRESENTACIÓN DE LAS INSTRUCCIONES
Trataremos, en esta sección, qué convenios se utilizan para representar e inter-

pretar las instrucciones en un computador. Es decir, cada computador tiene
0 NULL Nulo 20 DLE Escape de transmisión

1 SOH Comienzo de cabecera 21 DC1 Mando aparato aux. 1
2 STX Comienzo del texto 22 DC2 Mando aparato aux. 2
3 ETX Fin del texto 23 DC3 Mando aparato aux. 3
4 EOT Fin de la comunicación 24 DC4 Mando aparato aux.4
5 ENQ Pregunta 25 NAK Acuse recibo negativo
6 ACK Acuse de recibo 26 SYN Sincronización
7 BEL Timbre 27 ETB Fin bloque transmitido
10 BS Retroceso 30 CAN Anulación
11 HT Tabulación horizontal 31 EM Fin del soporte
12 LF Cambio de renglón 32 SUB Sustitución
13 VT Tabulación vertical 33 ESC Escape
14 FF Present. formulario 34 FS Separador archivo
15 CR Retroceso del carro 35 GS Separador grupo
16 SO Fuera de código 36 RS Separador artı́culo
17 SI En código 37 US Separador subartı́culo
40 Espacio 60 0 100 @ 120 P 140 160 p

41 ! 61 1 101 A 121 Q 141 a 161 q
42 ” 62 2 102 B 122 R 142 b 162 r
43 # 63 3 103 C 123 S 143 c 163 s
44 $ 64 4 104 D 124 T 144 d 164 t
45 % 65 5 105 E 125 U 145 e 165 u
46 & 66 6 106 F 126 V 146 f 166 v
47 ’ 67 7 107 G 127 W 147 g 167 w
50 ( 70 8 110 H 130 X 150 h 170 x
51 ) 71 9 111 I 131 Y 151 i 171 y
52 * 72 : 112 J 132 Z 152 j 172 z
53 + 73 ; 113 K 133 [ 153 k 173 {
54 , 74 < 114 L 134 \ 154 l 174 |
55 - 75 = 115 M 135 ] 155 m 175 }
56 . 76 > 116 N 136 ’ 156 n 176 ˜
57 / 77 ? 117 O 137 157 o 177 Del
Tabla 2.1: Código de caracteres ASCII en octal
un conjunto de instrucciones, y éste debe ser codificado de alguna manera me-

diante cadenas de unos y ceros. Pero además, como vimos en el capı́tulo 1, las
instrucciones deben especificar, no sólo el código de operación, sino también
los operandos.
2.3.1. Formatos de instrucciones. Introducción

El formato de las instrucciones es el modo en que organizamos una cadena de
1’s y 0’s para que nos dé información tanto del código de operación como de los
operandos. Dentro de esa cadena de 1’s y 0’s debe existir, por tanto, un campo
que llamaremos C.O. (código de operación) con el suficiente número de bits
para poder codificar todos los posibles códigos de operación. Además, deben
Lo/Hi 0 1 2 3 4 5 6 7 8 9 A B C D E F
0 NUL DLE DS SP & - { } \ 0
1 SOH DC1 SOS a j ∼ A J 1
2 STX DC2 FS SYN b k s B K S 2
3 ETX DC3 c l t C L T 3
4 PF RES BYP PN d m u D M U 4
5 HT NL LF RS e n v E N V 5
EOB
6 LC BS ET B
UC f o w F O W 6
P RE
7 DEL IL ESC
EOT g p x G P X 7
8 CAN h q y H Q Y 8
9 RLF EM \ i r z I R Z 9
A SMM CC SM ç ! | :
B VT . $ ’ #
C FF IFS DC4 < * % @
D CR IGS ENQ NAK ( ) ’
E SO IRS ACK + ; > =
F SI IUS BEL SUB | ¬ ? ”
Tabla 2.2: Código EBCDIC completo, de 8 bits. Por ejemplo, la letra J se

representa por D1h (primero el código de la columna seguido del de la fila)
existir campos adicionales para especificar el número de operandos necesarios.

Entenderemos por operandos tanto los datos a la entrada (argumentos de la
operación) como a la salida (resultados de la operación).
En función de los modos de direccionamiento (como veremos en el siguiente
epı́grafe) en el campo “operando” podemos almacenar directamente el dato con
el que vamos a operar; o la dirección de memoria donde se encuentra el dato;
o el registro del procesador donde está el dato, etc.
Uno de los problemas que podemos encontrar al diseñar el formato de las
instrucciones, aparece si estas instrucciones operan sobre una gran cantidad
de operandos, digamos n. En ese caso, el formato de la instrucción tendrá n
campos “operando” y, por tanto, necesitaremos bastantes bits para codificar
las instrucciones. Si queremos que las instrucciones no ocupen tanta memoria
podemos hacer los siguiente: vamos a especificar de forma explı́cita m operan-
dos (donde m < n) y los n − m operandos restantes que espera la instrucción,
deben ser colocados en ciertos registros predeterminados. De esta forma, el
número de campos “operando” del formato de la instrucción se ve reducido de
n a m.
2.3.2. Modos de direccionamiento

Existen diversas formas de especificar los operandos en una instrucción. A estas
distintas formas se les denomina modos de direccionamiento. Los tres modos
de direccionamiento básicos son el inmediato, directo e indirecto. Vamos a
comentar estos tres modos de direccionamiento para la misma instrucción: por
ejemplo, la instrucción “LOAD operando” cuya misión es cargar el operando
en un registro que llamaremos “acumulador” o AC.
1. Direccionamiento inmediato
Si el operando es una constante, podemos especificarlo directamente
en la instrucción.
Ej.: LOAD x ⇒ en el acumulador se cargará el número x.
2. Direccionamiento directo
No siempre trabajamos con constantes. En los programas se sue-
le trabajar con variables, que son aquellos datos cuyo valor varı́a en
el transcurso de la ejecución del programa. La implementación de una
variable en el nivel máquina se traduce en reservar una zona de alma-
cenamiento fija donde se guarda el dato (por ejemplo, una posición de
memoria o un registro -que es más rápido-).
Cuando hacemos referencia a una variable, utilizaremos el direccio-
namiento directo. Es decir, el campo “operando” nos proporcionará la
dirección de memoria (o el registro en su caso) donde se encuentra el
dato con el que queremos operar.
Ej.: LOAD [x] ⇒ trata x como la dirección de memoria donde está el
valor que se quiere cargar en el acumulador.
Diremos que el direccionamiento es directo a memoria si especifi-
camos la dirección de memoria donde está el operando. Diremos que el
direccionamiento es directo a registro si especificamos el registro en
el que se encuentra el operando.
El direccionamiento directo a registro es evidentemente más rápido
que el direccionamiento directo a memoria. Pero, además, el número de
bits del campo “operando” será menor con el direccionamiento a registro,
ya que hay menos registros que posiciones de memoria y, por tanto, los
registros se direccionan con pocos bits.
3. Direccionamiento indirecto
A veces no trabajamos con variables, sino con punteros a variables.
Un puntero no es más que otra variable que contiene la dirección de me-
moria donde se encuentra almacenada una variable. El direccionamiento
indirecto nos permite trabajar con punteros.
Ej.: LOAD [[x]] ⇒ trata x como la dirección de memoria donde está la

dirección del operando3 .
Diremos que el direccionamiento es indirecto a memoria si espe-
cificamos la dirección de memoria donde está la dirección del operando.
Diremos que el direccionamiento es indirecto a registro si especifica-
mos el registro donde está la dirección del operando.
El modo de direccionamiento puede estar indicado de forma implı́ci-
ta en el código de operación o de forma explı́cita mediante un campo
adicional. Evidentemente, también se debe especificar de alguna forma
(mediante un campo adicional en el formato de instrucción o de forma
implı́cita en el C.O.) si el direccionamiento es a registro o es a memoria.
Como es fácil suponer, el principal inconveniente del direccionamien-
to indirecto es su lentitud, ya que necesita un primer acceso (a memoria o
a registro) para conseguir la dirección del operando, y un segundo acceso
a memoria para conseguir el operando en sı́.
2.3.3. Modificaciones sobre los modos de direccionamiento

Llamaremos a partir de ahora dirección efectiva a la dirección en la que se
encuentra el operando. En general, podemos decir que los distintos tipos de
direccionamiento se distinguen unos de otros en el modo en que se calcula la
dirección efectiva (es decir, en el modo en el que se determina donde está el
operando).
Sobre los tres modos de direccionamiento básicos vistos anteriormente,
podemos definir algunas variaciones y combinaciones como las que veremos
ahora:
1. El direccionamiento directo a memoria puede ser:
Direccionamiento absoluto: el campo operando proporciona la di-
rección completa del operando en memoria. Para especificar la di-
rección completa necesitamos que el campo “operando” tenga un
número de bits igual al del bus de direcciones. Es decir, el tamaño de
las instrucciones que utilizan direccionamiento absoluto es grande.
Direccionamiento relativo: el campo operando contiene un des-
plazamiento respecto una posición conocida (dirección base) que
almacenamos en un registro determinado (registro base, registro
3
Modificamos la sintaxis de la instrucción (de LOAD a LOAD[[...]]) para indicar que uti-
liza direccionamiento indirecto. Es decir, el código de operación de la instrucción LOAD[[...]]
debe ser distinto al de la instrucción LOAD, y para hacérselo notar al ensamblador utiliza-
remos esta sintaxis.
de dirección, contador de programa, etc). El direccionamiento re-

lativo al Contador de Programa (PC), se emplea cuando los datos
están cerca de la instrucción que se está ejecutando. En este ti-
po de direccionamiento la dirección efectiva se calcula sumando el
desplazamiento a la dirección base.
Ventajas del direccionamiento relativo:
Se reduce la longitud de la instrucción.
Podemos mover o relocalizar un bloque de memoria en otra zona.
Por ejemplo, un programa donde sólo se utilice direccionamiento
relativo al PC funcionará de la misma forma independientemente
de cual sea la dirección inicial en la que esté cargado el programa.
Otro ejemplo lo podemos encontrar en el manejo de vectores: si que-
remos realizar una misma secuencia de accesos sobre dos vectores
almacenados a partir de dos posiciones distintas de memoria, pode-
mos escribir un código que realice esa secuencia de accesos relativa
al comienzo de un vector y, posteriormente, repetir la ejecución del
mismo código modificando únicamente la dirección de comienzo del
vector. En este caso, llamaremos dirección base a la dirección de
comienzo del vector, y registro base al registro que almacena la
dirección base. A este tipo de direccionamiento se le conoce con el
nombre de direccionamiento relativo a base.
Facilita el acceso secuencial a zonas de almacenamiento consecuti-
vo (vectores, matrices y arrays en general). Este tipo de acceso se
consigue utilizando una constante que apunta al comienzo de un
vector, a la que se suma el contenido de un registro (que llamare-
mos registro ı́ndice). El registro ı́ndice especifica qué “ı́ndice” del
vector es el que va a ser accedido. A este tipo de direccionamiento
se le conoce con el nombre de direccionamiento indexado. Un
caso particular del direccionamiento indexado es el direccionamien-
to autoindexado. En este modo, el registro ı́ndice se incrementa
o decrementa (dependiendo de como lo especifique el programador)
automáticamente después de cada acceso. Los dos modos básicos
de direccionamiento autoindexado son:
• con postincremento: el registro ı́ndice se autoincrementa des-
pués del acceso al operando.
• con predecremento: el registro ı́ndice se autodecrementa an-
tes del acceso al operando.
Inconvenientes del direccionamiento relativo:
Aumento de los circuitos lógicos para calcular la dirección efectiva,

lo que supone mayor coste.
Aumento del tiempo de cálculo de la dirección efectiva.
2. Direccionamiento de Pila
En ciertas ocasiones resulta útil emplear la memoria principal como
si fuese una “pila”. Una pila es una estructura LIFO: los datos están
accesibles sólo en el tope de la pila. La pila se direcciona implı́citamente
mediante el SP (Stack Pointer). El SP siempre apunta a la ultima po-
sición llena de la pila. Las instrucciones asociadas a una estructura pila
utilizan el direccionamiento de pila. Estas instrucciones son:
PUSH → mete un dato en la pila
POP → saca un dato de la pila
2.3.4. Número de direcciones

El problema que abordaremos ahora es el de determinar cuántas direcciones u
operandos proporcionamos a las instrucciones. Las posibilidades que podemos
encontrar en máquinas reales son:
3 direcciones: especificamos de forma explı́cita dos operandos fuentes y
un destino.
Ej: ADD x,y,z ⇒ El resultado de y+z se guarda en x (p.e. en varios
procesadores RISC como el R10000, el Alpha, etc.).
2 direcciones: perdemos un operando ya que especificamos de forma
explı́cita los dos operandos fuentes, pero el destino está implı́cito en
uno de los dos anteriores.
Ej: ADD x,y ⇒ El resultado de x+y se guarda en x (p.e. en los
procesadores de Intel) o en y (p.e. en los procesadores de Motorola).
1 dirección: Un operando fuente se proporciona de forma explı́cita, pero
el otro operando, ası́ como el resultado, quedan implı́citos.
Ej: ADD x ⇒ El resultado de x+AC se guarda en AC (suponiendo
que en la máquina en que se ejecuta esta instrucción, el convenio es que el
registro AC contenga los operandos implı́citos, como en el NEC 78000).
0 direcciones: Todos los operandos son implı́citos, por ejemplo, cuando
se trabaja con una pila.
Ej: ADD ⇒ El resultado de sumar los dos operandos que están en la
cima de la pila, se coloca en la cima de la pila.
Tener instrucciones con un número elevado de direcciones presenta ventajas
e inconvenientes:
Ventajas:
1. Los programas son más cortos lo que supone un menor gasto de
memoria
2. Las instrucciones son más potentes y los tiempos de ejecución me-
nores.
Inconvenientes:
1. Las instrucciones resultantes son más anchas, lo que supone gasto
de memoria.
2. Es necesaria una lógica adicional de decodificación.
Normalmente los procesadores potentes, y en particular los que siguen una
arquitectura RISC, utilizan un formato de instrucciones de tres direcciones.
En general, no suele ser interesante tener un número mayor de direcciones. En
procesadores más simples se toma como compromiso utilizar un formato de
dos direcciones.
Por otro lado, el número de direcciones puede variar de unas instrucciones
a otras, en función de cuantos operandos necesite. Por ejemplo, a la instrucción
NEG, que calcula el complemento a dos de un operando, no tiene sentido darle
un formato de tres direcciones.
2.3.5. Códigos de operación

El código de operación es el campo de la instrucción que especifica la opera-
ción a realizar. Si el modo de direccionamiento no está en un campo aparte,
también lo especificarı́a el código de operación. Es evidente que si el campo
reservado al C.O. tiene k bits, se pueden representar 2 k C.O. distintos.
Una de las técnicas más empleadas para reducir el tamaño de los programas
consiste en asignar códigos de operación más cortos a las instrucciones más
frecuentes. Es una técnica normal de codificación (códigos Huffmann, código
Morse).
El código de operación no tiene por qué tener una longitud fija. Es lo que
se denomina C.O. con extensión. Dependiendo de las instrucciones y de los
operandos que necesiten, los C.O. pueden ser más largos o más cortos.
2.3.6. Tipos de instrucciones

No olvidemos que aunque programemos en alto nivel, las máquinas no entien-
den directamente estos lenguajes, sino que ejecutan instrucciones máquina.
Es necesario un compilador para que traduzca cada sentencia de alto nivel en
instrucciones de código máquina. Elegir un conjunto de instrucciones apropia-
do facilitará la tarea de la compilación y dará lugar a códigos ejecutables de

mayores prestaciones.
Los requerimientos que debe cumplir un conjunto de instrucciones máquina
son:
1. Debe ser completo. Es decir, con el conjunto de instrucciones máquina
se ha de poder programar cualquier función computable utilizando una
cantidad de memoria razonable.
2. Debe ser eficiente. Las funciones más requeridas se deben ejecutar me-
diante pocas instrucciones rápidamente.
3. Debe ser regular. Deben existir los C.O. y modos de direccionamiento es-
perados (por ejemplo, si existe desplazamiento a la derecha, debe existir
también el desplazamiento a la izquierda).
4. Las instrucciones han de ser compatibles con las de procesadores de la
misma familia. De esta manera se reducen costes en el desarrollo SW.
Normalmente, el conjunto de instrucciones es distinto para procesadores de
casas o series distintas. Sin embargo, podemos decir que todos los procesadores
tienen instrucciones de los cinco tipos siguientes:
1. Instrucciones de transferencia (movimiento) de datos.
Ej.: LOAD, MOVE, PUSH, etc.
2. Instrucciones aritméticas: operaciones sobre datos numéricos.
Ej.: ADD, MUL, etc.
3. Instrucciones lógicas: operaciones booleanas y no numéricas.
Ej.: NOT, AND, OR, etc.
4. Instrucciones de control de programa: saltos, saltos condicionales, llama-
das a subrutinas.
5. Instrucciones de E/S: transferencia de datos entre el mundo exterior y
el procesador (un caso particular de las instrucciones de transferencia de
datos).
SINOPSIS
En este tema hemos analizado los convenios a los que han llegado los arqui-
tectos de computadores para representar la información mediante 1’s y 0’s.
Información que va desde datos numéricos, números negativos, números reales
por medio de un exponente y una mantisa, caracteres, hasta instrucciones,
operandos, etc. Ası́ mismo hemos abordado el problema del acceso a los datos,
mediante el estudio de los modos de direccionamiento. Y todo sólo mediante
1’s y 0’s.
RELACIÓN DE PROBLEMAS 35
RELACIÓN DE PROBLEMAS
Representación de los datos

1. Convierte los siguientes números decimales a binario: 1984, 4000, 8192.
2. ¿Qué número es 1001101001(2 en decimal? ¿En octal? ¿En hexadecimal?
3. ¿Cuáles de éstos son números hexadecimales válidos?: CAE, ABAD,
CEDE, DECADA, ACCEDE, GAFE, EDAD. Pasar los números válidos
a binario.
4. Expresa el número decimal 100 en todas las bases, de 2 a 9.
5. ¿Cuántos enteros positivos se pueden representar con k dı́gitos usando
números en base r?
6. El siguiente conjunto de 16 bits:
1001 1000 0101 0100
puede representar un número que depende del convenio utilizado.
Dar su significación decimal en el caso de que el convenio sea:
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
d) BCD natural (8,4,2,1)
e) BCD exceso a 3
f) BCD Aiken (2,4,2,1)
7. Para las siguientes representaciones de n bits, dar el rango, precisión,
representaciones del 0 y comparar el número de números positivos con
el de negativos.
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
8. Expresar los números decimales -63, 91 y -23 en signo/magnitud, en
complemento a uno y en complemento a dos utilizando una palabra de
8 bits.
9. ¿Cuántos bits son necesarios para representar todos los números entre
-1 y +1 con un error no mayor de 0.0001(10 en complemento a dos y con
notación en punto fijo?
10. Representar los siguientes números como flotantes IEEE-754 en simple
precisión.
a) 10
b) 10.5
c) 0.1
d) 0.5
e) -23.15625
11. ¿Qué inconveniente encontramos en la representación de números reales
en punto fijo?
Dados estos dos números en el formato IEEE 754: C0E80000 y 00080000;
decir que valores representan en decimal.
12. ¿Cuáles son los requisitos deseables de un sistema de numeración de
enteros con signo? ¿Qué sistema cumple mejor esos requisitos? Expresar
el número 9.75 en su representación IEEE 754 de 32 bits (convierte a
hexadecimal la palabra IEEE de 32 bits).
13. En una PDP-11 los números en punto flotante de precisión sencilla tienen
un bit de signo, un exponente en exceso a 128 y una mantisa de 24 bits.
Se exponencia a la base 2. El punto decimal está en el extremo izquierdo
de la fracción. Debido a que los números normalizados siempre tienen
el bit de la izquierda a 1, éste no se guarda; solo se guardan los 23 bits
restantes. Expresa el número 7/64 en este formato.
14. Expresa el número 7/64 en el formato IBM/360, y en el formato IEEE-
754.
15. Expresa el número en punto flotante de 32 bits 3FE00000 (16 como nú-
mero decimal si está representado en los siguientes formatos de 32 bits:
a) IEEE-754
b) IBM/360
c) PDP-11
16. Los siguiente números en punto flotante constan de un bit de signo,
un exponente en exceso a 64 y una mantisa de 16 bits. Normalı́zalos
suponiendo que la exponenciación es a la base 2 y que el formato NO es
del tipo 1.XXXX... con el “1” implı́cito.
0 1000000 0001010100000001
0 0111111 0000001111111111
0 1000011 1000000000000000
17. ¿Cuál son los números positivos más pequeño y más grande representa-
bles para los siguientes convenios?:
a) IEEE-754
b) IBM/360
c) PDP-11
Representación de las instrucciones
1. Diseña un código de operación con extensión que permita lo siguiente y

se pueda codificar en una instrucción de 36 bits:
a) 7 instrucciones con dos direcciones de 15 bits y un número de re-
gistro de 3 bits,
b) 500 instrucciones con una dirección de 15 bits y un número de
registro de 3 bits,
c) 50 instrucciones sin direcciones ni registros.
2. ¿Es posible diseñar un código de operación con extensión que permi-
ta codificar lo siguiente en una instrucción de 12 bits? Un registro se
direcciona con 3 bits.
a) 4 instrucciones con tres registros,
b) 255 instrucciones con un registro,
c) 16 instrucciones con cero registros
3. Cierta máquina tiene instrucciones de 16 bits y direcciones de 6. Algunas
instrucciones tienen una dirección y otras dos. Si hay n instrucciones
de dos direcciones, ¿cuál es el número máximo de instrucciones de una
dirección?
4. Queremos diseñar el formato de instrucciones de un procesador con 16
registros internos, y que puede direccionar 1 Kbyte de memoria. Dentro
del conjunto de instrucciones encontramos las siguientes:
a) 15 instrucciones del tipo:
Código de Op. Desp, Dirección, Dirección
b) 63 instrucciones del tipo:
Código de Op. Desp, Dirección, Registro
c) 60 instrucciones del tipo:
Código de Op. Dirección, Registro
d) 15 instrucciones del tipo:
Código de Op. Registro, Registro, Registro
e) 16 instrucciones del tipo:
Código de Op.
Donde el campo desplazamiento (Desp) nos permite implementar el
direccionamiento relativo, desplazándonos como máximo 63 bytes res-
pecto de la dirección base apuntada por la primera Dirección. El despla-
zamiento siempre será positivo.
Se pide:
a) Decir de cuántas direcciones es cada tipo de instrucciones (0, 1, 2

ó 3).
b) Diseñar el formato de cada tipo de instrucciones mediante códigos
de operación con extensión.
5. Dados los contenidos de las celdas de memoria que siguen y una máquina
de una dirección con un acumulador, ¿qué valores cargan en el acumu-
lador las instrucciones siguientes?
la palabra 20 contiene 40
a) LOAD 20
b) LOAD [20]
c) LOAD [[20]]
d) LOAD 30
e) LOAD [30]
f) LOAD [[30]]
6. Compara las máquinas de 0, 1, 2, y 3 direcciones escribiendo programas
para calcular
X = (A + B × C)/(D − E × F )
para cada una de las cuatro máquinas. Para que no se pierdan los valores
originales de las variables A, B, C, D, E y F podremos apoyarnos en
una variable temporal T. Suponiendo direcciones de 16 bits, códigos de
operación de 8 bits y longitudes de instrucción que son múltiplos de 4
bits, ¿Cuántos bits necesita cada computadora para calcular X?
3
Procesador Central
OBJETIVOS
Estudiar a nivel RTL la arquitectura del procesador central

Introducir los conceptos de subrutina, interrupciones y segmentación o
pipeline
Dar unos primeros pasos en el campo del lenguaje ensamblador
CAPÍTULO 3: PROCESADOR CENTRAL 41
3.1. INTRODUCCIÓN. ESTRUCTURA BÁSICA DE UN PRO-

CESADOR
Volvamos por un momento a la estructura de la máquina de von Neumann,

reorganizando ahora las unidades del computador desde un punto de vista más
moderno, como el presentado en la figura 3.1.
Unidad de CPU
Control
Unidad de
MEMORIA
Control
Entrada ALU Salida
Datos Control
Datos
Unidad de
Memoria Direcciones
Instrucciones Procesamiento
E/S
Figura 3.1: Unidades del computador
Como vemos, el computador se compone de los siguientes módulos:

1. Unidad Central de Proceso (UCP o CPU). Compuesta por una
unidad de control y otra de procesamiento (ALU más registros). Nor-
malmente se construye sobre una pastilla de silicio que llamaremos pro-
cesador o microprocesador (µP ).
2. Memoria. Subsistema en el que residen los programas y los datos. Este
subsistema se organiza en varios niveles conformando lo que se cono-
ce con el nombre de jerarquı́a de memoria: caché, memoria principal y
memoria secundaria (disco duro).
3. Unidad de Entrada/Salida. Mediante la cual se controla la entrada
y salida de información. Gestiona el manejo de periféricos en general:
teclado, monitor, impresora, ratón, etc.
Estas tres unidades se encuentran interconectadas mediante buses de co-
municación. Estos buses, no son más que lı́neas que transportan información
binaria entre los diversos subsistemas. Los podemos clasificar en función del
tipo de información que llevan:
Bus de direcciones. Mediante el cual la CPU selecciona la posición de me-
moria o la unidad de E/S de la cual va leer información o en la cual va a
escribir información. Evidentemente, si el bus tiene n lı́neas, tendremos

acceso a 2n posiciones distintas (a repartir entre RAM, ROM y E/S).
Este bus es unidireccional.
Bus de datos. Mediante el cual se transfiere información de (hacia) la me-
moria o E/S hasta (desde) el procesador. Es un bus bidireccional y nor-
malmente determina la palabra de trabajo del procesador (si el bus tiene
n lı́neas decimos que el procesador es de n bits).
Bus de control. Mediante el cual se transfiere información de control entre
el procesador, memoria y E/S. Es un bus bidireccional.
Podemos caracterizar un bus por el número de lı́neas de comunicación en
paralelo (bits) que lo componen y por la frecuencia de transmisión de los datos
en Hz. Ambos parámetros pueden en este caso fundirse en una sola magnitud,
que actúa como métrica de su rendimiento, y que se conoce como ancho de
banda (BW, del inglés “bandwidth”), indicando la velocidad de comunicación
por el bus en bits por segundo (bps.). Por ejemplo, el bus local PCI del Pentium
tiene una anchura de 64 lı́neas y una frecuencia de 66 MHz., lo que proporciona
un ancho de banda de 528 Mbytes/s.
En este tema nos centraremos en el procesador central de forma general. Es
el componente más complejo del sistema y su misión es sincronizar y coordinar
el funcionamiento de los demás módulos del sistema, leyendo, decodificando y
ejecutando instrucciones.
3.1.1. Caracterı́sticas principales del procesador

1. Longitud de palabra.
Definida por el n.o de bits del bus de datos, bus de direcciones, ta-
maño de los registros o por el n.o de bits con que la ALU puede operar en
paralelo. En los procesadores modernos la longitud de palabra impone
un limite máximo al rango de direccionamiento de memoria.
Normalmente los registros de la máquina tienen la misma anchura,
pero no tiene porqué ser ası́. Por ejemplo, el 68000 de Motorola tiene
registros de 32 bits, pero tiene un bus de datos de 16 bits. El Intel 8088
tiene registros de 16 bits y un bus de 8 bits.
De cualquier modo, el que la longitud de palabra sea 32 bits (por
ejemplo), no quiere decir que toda la información en este µP particular
ocupe 32 bits. Es decir, podemos codificar caracteres con 8 bits, códigos
de operación con 16 bits y números en punto flotante de doble precisión
con 64 bits.
En general nos referiremos con longitud de palabra del procesador al
número de bits de los registros accesibles al programador (anchura de la

ALU).
2. Velocidad de proceso.
Estará en función de ciertos parámetros de diseño:
Frecuencia de reloj (33MHz, 100MHz, 200MHz, etc)
Tiempo de ejecución de cada instrucción: CPI (ciclos de reloj por
instrucción)
Tiempo de acceso a memoria y a E/S. Normalmente estas dos uni-
dades ralentizan en gran medida al sistema completo.
El tiempo que un procesador invierte en la ejecución de un programa
puede obtenerse como el producto de tres factores:
a) N I: Número de instrucciones máquina en que se transforma el pro-
grama.
b) CP I: Número medio de ciclos de reloj que se necesitan para ejecutar
cada instrucción máquina.
c) T : Tiempo de ciclo de reloj (o su frecuencia f como magnitud in-
versa).
Es decir, TCP U = N I ×CP I ×T = N I×CP f
I
, donde TCP U resultará en
la misma magnitud en que expresamos el perı́odo T, por ejemplo, en
microsegundos si la frecuencia f viniera expresada en MHz.
El primero de esos factores depende principalmente del compilador.
Si éste está optimizado para un procesador, será capaz de traducir un
programa de alto nivel (escrito en C, por ejemplo) en un programa objeto
o ejecutable que contenga el menor número de instrucciones máquina
posibles.
El segundo factor, CPI, está más relacionado con el conjunto de ins-
trucciones del procesador. Por ejemplo, un procesador RISC, (cuyo con-
junto de instrucciones se compone de pocas instrucciones muy sencillas)
puede reducir el CPI incluso a la unidad, pero a costa de incrementar NI.
Para ello, una de las técnicas que utiliza es la de segmentar (“pipeline”)
la ejecución de instrucciones dentro del procesador.
El tercer factor es la frecuencia de reloj del procesador, que está más
relacionada con su tecnologı́a hardware y con las técnicas de integración
de circuitos. La positiva evolución de éstas ha permitido duplicar la
frecuencia del procesador cada 2 ó 3 años en las dos últimas décadas.
3. Capacidad de proceso.
En relación con:
a) Número de instrucciones del µP, distinguiendo entre los del tipo
CISC (Complex Instruction Set Computer) y RISC (Reduced Ins-

truction Set Computer). Con relación a este parámetro se utiliza
la métrica MIPS (millones de instrucciones por segundo) que viene
definida como:
NI
M IP S = · 10−6
TCP U
La principal ventaja de los MIPS es que son fáciles de comprender.
Sin embargo, son dependientes del repertorio de instrucciones, pues
a mayor complejidad de las instrucciones máquina de un procesa-
dor, menor número de MIPS producirá un programa concreto, sin
que eso indique que el programa se está ejecutando más lentamente.
b) Operaciones que puede realizar la ALU (aritmética entera, BCD,
formato en punto flotante de simple o doble precisión, división y
multiplicación por HW o por SW, etc...). Los MFLOPS o millo-
nes de operaciones en punto flotante por segundo (del inglés Mi-
llion of FLoating-point Operations Per Second), caracteriza la velo-
cidad de la unidad en punto flotante y por otro lado es una métrica
que está basada en operaciones en lugar de instrucciones como los
MIPS.
4. Gestión de memoria.
Se refiere a las caracterı́sticas que posee el µP en relación con la
gestión de memoria. Por ejemplo, si incluye HW para el manejo de caché,
si lleva un nivel de caché interno, si implementa una unidad de manejo
de memoria (MMU) para gestionar la memoria virtual, etc.
Los dos parámetros principales que influyen en las prestaciones de
una memoria son su tamaño en número de palabras y su latencia o
tiempo de respuesta expresado normalmente en nanosegundos (ns.). El
tamaño aumenta la funcionalidad del sistema al permitir ejecutar apli-
caciones más complejas, mientras que la latencia está más ligada a la
rapidez de ejecución de los programas. El número de bytes que la memo-
ria sea capaz de proporcionar por unidad de tiempo, es decir, su ancho
de banda vendrá dado como:
longitud de palabra de memoria

BW =
latencia
Capacidad y latencia son parámetros inversamente ligados con res-
pecto al precio, es decir, a mayor tamaño, menor rapidez por el mismo
precio. Por ejemplo, las memorias caché actuales tienen un tamaño de
256-512 Kbytes y una latencia de unos pocos ns., la memoria principal

o RAM presenta un tamaño de entre 16 y 128 Mbytes y una latencia
de decenas de ns., y la memoria secundaria o disco duro llega a varios
Gbytes, pero sube la latencia a los milisegundos.
5. Manejo de interrupciones y capacidad de interfaz.
Se refiere a las capacidades del µP para relacionarse con otros dispo-
sitivos externos. Por ejemplo, como maneja las interrupciones, si soporta
dispositivos de acceso directo a memoria (DMA) para acelerar la trans-
ferencia de datos entre periféricos y memoria, etc.
3.2. SUBSISTEMAS DE DATOS Y DE CONTROL
Como hemos repetido en otras ocasiones, el procesador engloba las unidades

de control, de datos y los registros. En este apartado daremos una primera
introducción a estos tres bloques:
3.2.1. Registros
Los registros son dispositivos digitales que nos permiten almacenar informa-
ción y acceder a ella en tiempos bastante menores que el que necesitarı́amos
para acceder a memoria. Podemos clasificar los registros que podemos encon-
trar en un µP en función de la información que almacenan:
1. Registros de propósito general (RPG): En estos registros alma-
cenamos la información que utilizamos más frecuentemente (ya que el
acceso a memoria es más lento). Podemos distinguir dos subtipos de
RPG’s:
Registros de datos: Almacenan datos y tienen normalmente un
número de bits igual al de la palabra del µP.
Registros de direcciones: Normalmente almacenan direcciones, por
lo que deben tener un tamaño igual al del bus de direcciones.
2. Contador de Programa (PC o IP): Contiene la dirección de memo-
ria de la cual se leerá la siguiente instrucción a ejecutar. Normalmente
el contenido del PC se incrementa al ejecutar cada instrucción para que
“apunte” a la siguiente instrucción a ejecutar. Si modificamos el conteni-
do del PC cargándolo con la dirección x, estamos realizando un “salto”
a la instrucción almacenada en la posición x de memoria.
3. Registro de Instrucciones (RI): Almacena el código de operación
de la instrucción que estamos ejecutando en un momento dado. Es un
registro “transparente al usuario”, es decir, el usuario o el programador

no pueden acceder a ese registro y modificar su valor, sino que es un
registro que actualiza automáticamente la sección de control del µP.
4. Acumuladores: En muchos µP hay uno (o varios) registros acumulador
(AC) en el que implı́citamente hay un operando y donde se “acumula”
el resultado. En caso de no tener registro AC, podemos utilizar registros
de propósito general.
5. Registro ı́ndice y registro base: Pueden ser registros de direcciones
que se utilizan para el direccionamiento relativo a base (el registro base
contiene la dirección base a cierta posición de memoria) o para el di-
reccionamiento indexado (el registro ı́ndice va apuntando a las distintas
posiciones de una estructura de datos con almacenamiento consecutivo:
arrays, cadenas alfanuméricas, etc).
6. Puntero de Pila (Stack Pointer -SP-): Puede ser un registro de
dirección que contiene el puntero a la posición de la pila escrita más
recientemente (la cima de la pila).
7. Registros temporales: Normalmente incluidos dentro del µP para
guardar resultados intermedios de algunas operaciones (por ejemplo, la
instrucción XCHG, que intercambia el contenido de dos registros necesita
de un registro temporal para realizar el intercambio). Estos registros no
suelen ser accesibles por el usuario (son transparentes al usuario).
8. Registro de estado o de banderas (Flags Reg. o SR): Es un regis-
tro en el que cada bit o campo de bits tienen información independiente,
normalmente relacionada con el resultado de las operaciones realizadas
en la ALU. A cada uno de esos bits independientes se le llama bandera
(flag) y se activan o desactivan en función de la ejecución de ciertas ins-
trucciones. Estos flags son testeados o chequeados por otras instrucciones
para realizar saltos condicionales.
Los flags más comunes son los siguientes:
a) Cero (Z): Se pone a 1 si el resultado de una operación es 0.

b) Carry (C): Se pone a 1 si el resultado de una operación provoca un
acarreo de salida.
c) Signo (S): Se pone a 1 si el resultado de una operación es negativo.
d) Overflow (O): Se pone a 1 si el resultado de una operación se ha
salido del rango de valores representables.
e) Paridad (P): Se pone a 1 si el resultado de una operación da lugar
a una palabra con un número par de 1’s (o un número impar de
1’s, dependiendo del convenio).
Otros flags no son el resultado de realizar operaciones con datos, sino

que son activados o desactivados por el programador para obligar al µP
a trabajar en uno de varios modos posibles:
a) Habilitación/Deshabilitación de interrupciones: El progra-
mador pone a 1 este flag si quiere permitir las interrupciones de
otros dispositivos. En caso de no aceptar interrupciones, éstas pue-
den ser enmascaradas poniendo a 0 este flag.
b) Traza: A 1 habilita la ejecución de instrucciones paso a paso (modo
de depuración de programas).
c) Supervisor: A 1 el procesador trabaja en modo supervisor (modo
de alta prioridad en el que se pueden ejecutar instrucciones privi-
legiadas y no hay limitaciones en el acceso a datos -es el modo en
que trabaja el Sistema Operativo-). A 0 el procesador trabaja en el
modo normal o modo de usuario.
3.2.2. Unidad de Datos

También llamada Sección de Procesamiento, donde el módulo principal es la
Unidad Aritmético-Lógica. Este módulo (ALU) contiene la circuiterı́a necesa-
ria para realizar las operaciones aritméticas y lógicas. Normalmente la ALU
sólo realiza operaciones enteras, por lo que también se la conoce con el nom-
bre de “unidad entera” para diferenciarla de la “unidad en punto flotante” o
FPU4 .
La unidad entera, también es la encargada de calcular la dirección efectiva
del operando (ya que en los direccionamientos relativos es necesario realizar
sumas o restas para determinar la dirección del operando).
El número de operaciones que puede realizar la ALU y la velocidad de
procesamiento dependen en gran medida de la cantidad de HW que utilicemos
para implementar las distintas funciones. Podemos abaratar costes en el desa-
rrollo de la ALU emulando ciertas operaciones mediante SW, de forma que no
sea necesario incluir un HW especı́fico para esas operaciones. Sin embargo, el
tiempo de ejecución de estas instrucciones emuladas mediante SW es mayor.
Como vemos en la figura 3.2 la ALU se alimenta de los registros o de
memoria (a través del bus de datos). La salida de la ALU también puede
almacenarse en registros o en memoria. También debe existir una entrada de
control que indique a la ALU que operación debe realizar (en el caso de la
4
La FPU también puede estar incluida dentro del µP o colocarse externamente como
coprocesador matemático.
figura, las señales c6, c7 y c8 codifican la operación que debe realizar la ALU).
Además, la ALU debe actualizar el registro de Estados (SR) después de cada
operación.
BUS 8
c1
0 MUX 1 c11
8 8 8
c9
SR c6
COS Z ALU c7
8 bits c8
c3 c2
8 c4
c10
AC X
8
8
c5
Figura 3.2: Una posible Sección de Procesamiento
Como vemos en la figura 3.2, esta sección de procesamiento tiene varios

“puntos de control” (de c1 a c11) que deben ser activados adecuadamen-
te para que el secuenciamiento de las operaciones dé lugar a una ejecución
correcta de las instrucciones.
El modo particular en el que interconectamos los registros, la ALU, el
SR, etc, determina lo que llamaremos el “flujo de datos” (Data Path). Este
flujo de datos determina cuáles son los posibles caminos que puede tomar la
información durante su procesado.
3.2.3. Unidad de Control

También llamada Sección de Control. Es la unidad que genera las señales de
control que “atacan” los puntos de control de la sección de procesamiento.
Por tanto, esta unidad debe tener la circuiterı́a de control, temporización, y
decodificación de instrucciones.
En la figura 3.3 podemos ver un esquema a alto nivel de una sección de
control. A partir del contenido del registro de instrucciones, la sección de
control debe generar las señales de control para que se ejecute dicha instrucción
adecuadamente.
Después del ciclo de búsqueda (fetch), en el registro de instrucción encon-
traremos la instrucción que vamos a ejecutar. El código de operación de esta
instrucción debe ser decodificado durante la fase de decodificación, de forma
que la sección de control interprete el objetivo de la instrucción en curso. Una
vez decodificada la instrucción, debemos ejecutarla generando de forma se-
cuencial las señales de control que activan las distintas funciones de la sección
de procesamiento.
RI C.O. MD Op 1 Op 2
DECOD
SECUENCIADOR CK
.....
c1 c2 c3 c4 c5 cn
Figura 3.3: Esquema a alto nivel de una sección de control
Para conseguir este objetivo, la sección de control contiene un decodificador

y un secuenciador (una máquina de estados secuencial alimentada por una
señal de reloj). El decodificador decodifica el código de operación en curso y

genera un conjunto de señales que inicializan el secuenciador colocándolo en un
estado inicial. Este estado inicial será distinto para las distintas instrucciones
a ejecutar. A partir de este estado inicial el secuenciador evolucionará a través
de ciertos estados, cada uno de los cuales generará ciertas señales de salida
(señales de control) que activarán los distintos puntos de control de la sección
de procesamiento.
A cada conjunto de señales de control para un estado dado se le llama
microinstrucción, y por tanto la ejecución de cada instrucción máquina
(macroinstrucción) se traduce en un conjunto de micro-instrucciones. El
conjunto de microinstrucciones que ejecutan una determinada macroinstruc-
ción se conoce con el nombre de microsubrutina.
Existen básicamente dos técnicas para construir el secuenciador:
1. Técnica cableada: El secuenciador se construye mediante una máquina
de estados compuesta de puertas, contadores, registros, decodificadores,
etc. La interconexión de estos elementos es un poco heurı́stica, poco
sistemática y da lugar a secciones de control complicadas, pero bastante
rápidas. Es la técnica de control utilizada en los procesadores RISC.
2. Técnica microprogramada: El secuenciador se construye mediante un
contador de microprograma que apunta a las distintas microinstrucciones
almacenadas en una memoria (llamada micro-memoria). Esta técnica es
más sistemática y pedagógica, pero da lugar a secciones de control más
lentas. Es la técnica utilizada en los procesadores CISC.
3.3. CICLO MÁQUINA Y ESTADOS DE UN PROCESA-

DOR
Como hemos comentado en alguna otra ocasión, la ejecución automática de

un programa por un computador se lleva a cabo mediante el procesado de
las instrucciones contenidas en el programa. A su vez, la ejecución de estas
instrucciones se efectúa por el uso repetitivo de ciertas operaciones del sistema,
a saber:
Búsqueda de instrucción. El procesador “busca” en la posición de memo-
ria apuntada por el registro PC una instrucción que carga en el registro
RI.
Decodificación. El C.O. de la instrucción se analiza para determinar que
función debe realizar la instrucción. En términos más realistas, podemos
decir que el C.O. decodificado proporciona un estado inicial a la unidad
de control, de forma que ésta genere la información de control necesaria

para ejecutar esta instrucción en particular. También en esta fase se
incrementa el PC para que apunte a la siguiente instrucción a ejecutar.
Cálculo de la dirección efectiva. En caso de que la instrucción necesite
operandos almacenados en memoria, se determina la dirección en la que
se encuentran dichos operandos: la dirección efectiva o EA (efective ad-
dress).
Búsqueda de operandos. Acceso a memoria para leer los operandos de la
instrucción.
Ejecución. Realización de la función especificada por la instrucción. Una
vez concluida esta fase volvemos a la fase de búsqueda de la siguiente
instrucción.
Antes de entrar en este bucle de ejecución de instrucciones hay que ini-
cializar el computador para ejecutar un determinado programa. Para ello el
sistema operativo debe:
1. Cargar el programa y los datos en memoria
2. Inicializar el PC para que apunte a la primera instrucción del programa
a ejecutar.
Llegados a este punto podemos formular las siguientes definiciones:
Ciclo de instrucción. Tiempo necesario para leer y ejecutar una instruc-
ción. El ciclo de instrucción es mayor para instrucciones más lentas y
menor para instrucciones más rápidas. Normalmente el ciclo de instruc-
ción se mide en ciclos de reloj. Por ejemplo, en el 8086 de Intel la ins-
trucción ADD necesita 3 ciclos de reloj para completarse; la instrucción
MUL necesita de 70 a 77 ciclos de reloj.
Ciclo máquina. Subperiodos en que se divide un ciclo de instrucción. Estos
subperiodos pueden necesitar también uno o varios ciclos de reloj. En el
tema siguiente veremos en detalle en qué consiste el ciclo máquina.
3.3.1. Modos de secuenciamiento

Nos referiremos aquı́ a la secuencia en que se pueden ejecutar las instrucciones
dentro de un programa. Básicamente podemos distinguir cuatro modos:
1. Ejecución secuencial: Las instrucciones se ejecutan de forma secuen-
cial incrementándose el PC sin discontinuidades. Es decir, se ejecutan en
orden las instrucciones almacenadas consecutivamente en memoria.
2. Salto (transferencia de control): Mediante las instrucciones de salto el
PC se puede cargar con una dirección distinta a la siguiente. De esta
forma se transfiere el control a otro punto del programa. El valor previo

del PC (antes del salto) se pierde al modificar el contenido de éste.
3. Subrutina (transferencia de control): El valor del PC se modifica de
forma que se provoca una transferencia de control a otro punto del pro-
grama (donde comienza una subrutina). La diferencia con el salto estriba
en que el valor del PC (antes de su modificación) se “salva” en la pila.
Para llamar a la subrutina se utiliza la instrucción call. La subrutina
termina con una instrucción ret (de return) de forma que se recupera el
valor del PC almacenado en la pila y la ejecución sigue por la instrucción
siguiente al call.
4. Interrupción (transferencia de control): Mediante este modo también
se produce una transferencia de control a una subrutina (llamada aho-
ra subrutina de tratamiento de interrupción), pero, en general, dicha
transferencia no la provoca el programador, sino que puede ocurrir en
cualquier momento de la ejecución del programa. Por tanto, en la pila
no debemos salvar únicamente el PC, sino también el resto del “estado
de la máquina” (registro de estados, registros de propósito general, etc.).
Al terminar la rutina de tratamiento de interrupción recuperamos el PC
y el estado de la máquina y continúa la ejecución del programa.
3.3.2. Técnica pipeline de instrucciones

La técnica de segmentación o pipeline consiste en dividir una tarea en sub-
tareas y ejecutar cada una de estas subtareas mediante una unidad funcional
independiente. Por ejemplo, la tarea de fabricación de un coche se puede dividir
en varias subtareas y ejecutar cada una de ellas por un operario dentro de una
cadena de montaje. Esta estrategia se puede aplicar dentro de un procesador
para acelerar la ejecución de instrucciones.
Por ejemplo, el 8086 de Intel, divide la tarea de ejecutar una instrucción
en dos subtareas:
1. Búsqueda de instrucción
2. Decodificación, cálculo de EA, búsqueda de op. y ejecución
El 8086 dedica una unidad llamada BIU (unidad de interfaz del bus) a la
búsqueda de instrucciones y otra unidad independiente, EU (unidad de eje-
cución), a la ejecución de instrucciones. Las dos unidades operan en paralelo,
de forma que mientras se ejecuta la instrucción actual, ya se está buscando la
instrucción siguiente en paralelo. De esta forma conseguimos reducir el tiempo
de ejecución. Este caso particular de pipeline de dos etapas se conoce con el
nombre de prefetch (prebúsqueda).
En general, podemos utilizar tantas unidades funcionales como subtareas

queramos ejecutar. Por ejemplo, podrı́amos haber dedicado una unidad fun-
cional para cada una de las 5 fases: búsqueda de instrucción, decodificación,
cálculo de la EA, búsqueda de op. y ejecución; de forma que, en el caso ideal,
el tiempo de ejecución de un programa se divide por 5.
3.4. EJEMPLO: MICROPROCESADOR 8086
3.4.1. Caracterı́sticas generales

El 8086 y 8088 son microprocesadores de Intel de propósito general. Ambos son
prácticamente idénticos excepto por el tamaño de su bus de datos externo. En
el caso del primero, el bus de datos es de 16 bits, mientras que en el segundo,
es de 8 bits. La razón para crear el 8088 con este bus de datos reducido fue
prever la continuidad entre el 8086 y los antiguos procesadores de Intel (8085).
En este ejemplo nos centraremos en el 8086.
Resumen de las caracterı́sticas:
Microprocesador de 16 bits (ancho del bus de datos)
Bus de direcciones de 20 bits (máxima memoria direccionable: 1 Me-
gaByte).
E/S no mapeada en memoria. El espacio de direcciones de E/S es inde-
pendiente del de memoria. Tamaño del espacio de E/S es de 64Kbytes
Encapsulado de 40 pines. Algunas señales multiplexadas.
Segmentación. Dos etapas: B.I.U (unidad de interfaz con el bus), que
realiza la búsqueda (prefetch), y E.U (unidad de ejecución), que recoge
las instrucciones de la cola de la B.I.U. y las ejecuta.
3.4.2. Registros
El 8086 presenta un conjunto de 14 registros de 16 bits que se pueden agrupar
de la siguiente forma:
Registros generales : Su función es el almacenamiento temporal de datos.
AX (acumulador). Es utilizado en las instrucciones aritméticas.
BX (base). Se usa generalmente para indicar un desplazamiento.
CX (contador). Se utiliza en bucles.
DX (datos). Se utiliza también en operaciones aritméticas.
Estos registros ofrecen la posibilidad de usarse además como registros
de 8 bits, refiriéndose al byte más significativo con AH, BH, CH y DH o
al menos significativo con AL, BL, CL y DL respectivamente.
Registros de segmento : Contienen la dirección de comienzo de los segmen-

tos de memoria que conforman un programa.
CS o registro de segmento de código. Contiene la dirección del segmento
donde están las instrucciones del programa.
DS o registro de segmento de datos. Hace referencia al comienzo del
segmento de datos.
SS o registro de segmento de pila.
ES o registro del segmento extra. Se trata de un segmento que es utiliza-
do para efectuar transferencias entre los tres segmentos principales.
Punteros : Se utilizan para designar el desplazamiento actual dentro de un
segmento.
SP Puntero de pila.
BP Puntero base.
IP Puntero de instrucciones. Contiene el desplazamiento de la instruc-
ción siguiente a ejecutar respecto al segmento de código del progra-
ma en ejecución.
Registros de ı́ndice : Se utilizan como desplazamiento relativo a un campo
de datos.
SI Índice fuente.
DI Índice destino.
Registro de banderas (flags) : Sólo 9 de los 16 bits son significativos.
Los flags registran el estado del procesador después de una operación.
CF (Carry). Indica acarreo en las operaciones aritméticas.
OF (Overflow). Desbordamiento aritmético.
ZF (Zero). Se activa cuando el resultado de una operación es cero.
PF (Parity). Número par de bits.
SF (Sign). Bit de signo del resultado.
AF (Auxiliar). Relativo al uso de números en BCD.
Las banderas de control son tres. Registran el modo de funciona-
miento del procesador.
DF (Direction). Controla la dirección (hacia delante o atrás) en las
operaciones con cadenas de caracteres, incrementando o decremen-
tando SI y DI.
IF (Interrupt). Controla la habilitación de las interrupciones.
TF (Trap). Controla la operación modo paso a paso.
3.4.3. Gestión de memoria

El bus de direcciones del 8086 es de 20 bits. Esto supone que el espacio de
direccionamiento disponible es de 220 = 1 Mbyte. Cada una de estas posiciones
de memoria se puede referenciar mediante un conjunto de 20 bits. Los registros
internos de que dispone el microprocesador son de 16 bits, por lo que es nece-
sario un pequeño truco para generar la dirección de 20 bits a partir de dos de
estos registros. Esto se consigue introduciendo el concepto de segmentación.
El espacio de direccionamiento del microprocesador se divide en bloques de
64 Kb, cada uno denominado segmento, de forma que, para hacer referencia a
una posición de memoria determinada, hay que expresar el segmento en el que
se encuentra y el desplazamiento que ocupa dentro de ese segmento. A esta
forma de referenciar las posiciones de memoria se denomina direccionamiento
lógico. De esta forma, una dirección lógica está formada por dos números, el
primero expresa el segmento y el segundo el desplazamiento.
✞ ☎
Dirección lógica = Segmento: Desplazamiento
✝ ✆
El segmento hay que indicarlo siempre en un registro de segmento (CS, DS,
etc..) y el desplazamiento puede expresarse de distintas formas, dando lugar
a los distintos modos de direccionamiento. Como vemos, la dirección fı́sica de
20 bits (5 dı́gitos hexadecimal) se representa como dos enteros de 16 bits (4
dı́gitos hexadecimal). Por convenio, segmento y desplazamiento son números
de 16 bits positivos.
Mediante este sistema es posible direccionar 16 * 64Kb = 1024 Kb = 1Mb
posiciones de memoria. La conversión de esa dirección lógica a dirección fı́sica
se realiza desplazando el registro de segmento 4 bits a la izquierda y sumándole
el contenido del registro de desplazamiento.
✞ ☎
Dirección fı́sica = Segmento * 10h + Desplazamiento
✝ ✆
Se observa que el mapeo de direcciones fı́sicas en direcciones lógicas no es
biunı́voco.
Esquema de almacenamiento
Este procesador sigue la regla “el byte menos significativo ocupa la posición
más baja” (Little Endian). Ası́, si escribimos un dato en una posición de me-
moria, dependiendo si es byte, word, doble word,... se ubica en memoria según
se esquematiza en la figura 3.4. La dirección de un dato es la de su byte me-
nos significativo. La memoria siempre se referencia a nivel de byte, es decir,

si decimos la posición N nos estamos refiriendo al byte N -ésimo de memoria,
aunque se escriba una palabra, doble palabra,...
N+3 N+3 N+3 12

N+2 N+2 N+2 34
N+1 N+1 12 N+1 56
N 12 N 34 N 78
MOV BYTE PTR LAB, 12H MOV WORD PTR LAB, 1234H MOV DWORD PTR LAB, 12345678H
EA(LAB)=N
Figura 3.4: Ubicación de datos en memoria
Modos de direccionamiento
Direccionamiento inmediato: MOV AX,100H

Direccionamiento directo a registro: MOV AX,BX
Direccionamiento directo a memoria: MOV AX, [LABEL]
Direccionamientos indirectos a registro:
• Direccionamiento relativo a registro ı́ndice (SI,DI): MOV AX,[SI] ;
MOV AX,[SI-3]
• Direccionamiento relativo a registro base (BX,BP): MOV AX,[BP+2]
• Direccionamiento base-ı́ndice con/sin desplazamiento:
MOV AX,5[BX+DI]; MOV AX,LABEL[BX][DI];
MOV AX,LABEL[BP+DI+5]
• Direccionamiento de pila: PUSH AX; POP AX
Nota: En los modos de direccionamiento relativo a registro, el contenido
del registro es el desplazamiento de la dirección de memoria. El segmento de
la posición que está referenciando es por defecto DS, salvo que el registro base
sea BP en cuyo caso el segmento es el contenido de SS. También se puede
indicar explicitamente el semento, por ejemplo: MOV AX, SS:[BP]
3.4.4. Sistema de interrupciones
Dicho sistema emplea interrupciones vectorizadas que se pueden activar bien

por hardware o software. Existen 256 interrupciones posibles (IN T 0...IN T 255).
Cada interrupción tiene asociado un vector formado por 4 bytes, que recoge
la dirección de memoria donde se encuentra la rutina de tratamiento de dicha
interrupción (CS:IP). Estos vectores de interrupción forman una tabla que se
encuentra en la parte más baja de la memoria, al comienzo de la RAM. En
total existen 256 vectores de interrupción, de forma que la tabla de vectores
ocupa 256×4 = 1Kb de memoria. La disposición fı́sica del vector de interrup-
ción de la interrupción N es: [N × 4 + 3, N × 4 + 2] =CS, [N × 4 + 1, N × 4] =IP,
donde CS:IP es la dirección de la rutina de atención a la interrupción. (Con
[K + 1, K] denotamos el contenido de la palabra situada en la posición K de
memoria). Como se acaba de ver, el vector de interrupción de la IN T N , es
una doble palabra situada en la posición fı́sica de memoria N × 4.
Las fuentes de interrupción en este procesador son:
- Lı́neas de interrupción (hardware): INTR (interrupción enmasca-
rable) y NMI (interrupción no enmascarable). La interrupción no en-
mascarable da lugar a la ejecución de la interrupción IN T 2. Si se quieren
atender más de una interrupción enmascarable (teclado, ratón, ...), se
ha de usar un controlador de interrupciones (PIC), por ejemplo el 8259.
- Interrupción software: Invocada desde el programa con la instrucción
INT N, siendo N el número de la interrrupción a ejecutar.
El mecanismo de atención a una interrupción sigue el siguiente esquema:

1. Cuando se activa la interrupción, se debe guardar en la pila la dirección
de la instrucción que está ejecutando la CPU, para poder volver después
a ella. También se debe guardar el registro de estado, por si la rutina
modifica alguna de las banderas.
2. Se busca en la tabla de vectores de interrupción la dirección donde se
encuentra la rutina que se debe ejecutar.
3. Se carga CS:IP con el contenido del vector de interrupción asociado.
4. Se ejecuta la rutina de atención a la interrupción.
5. La ultima instrucción de la rutina es IRET, que se encarga de restaurar
desde la pila CS, IP y el registro de banderas.
6. Se continúa ejecutando el programa por la instrucción siguiente a la que
se interrumpió.
3.4.5. Ensamblador del 8086

La principal caracterı́stica de un módulo fuente en ensamblador es que existe
una clara separación entre las instrucciones y los datos. De hecho, un modulo
fuente está formado por tres bloques independientes que se van a ubicar en
tres segmentos distintos en la memoria RAM.
La estructura más general de un módulo fuente es:
* Segmento de datos. En este bloque se definen todas las variables que
utiliza el programa con el objeto de reservar memoria para contener los
valores asignados.
* Segmento de código. Este segmento incluye todas las instrucciones que
forman el programa. En un mismo módulo fuente pueden existir más de
un segmento de código.
* Segmento de pila. La pila es un tipo de memoria auxiliar donde se al-
macenan datos temporalmente. Es una memoria de tipo LIFO y existe
un puntero que direcciona la cima de la pila. El segmento de pila indica
la dirección de memoria donde se posiciona la pila y reserva un número
determinado de posiciones consecutivas en memoria.
De estos tres segmentos, el único que obligatoriamente debe existir es el
segmento de código.
3.4.6. La pila
La pila de un programa ensamblador se define con la directiva SEGMENT STACK.
Si N + 1 es la longitud en bytes reservada para la pila, la zona de pila es la
comprendida entre la direcciones: SS:0000H y SS:N. De esta manera, SP se
inicializa al valor N + 1. El convenio es que SP apunte a la última palabra
(posición más baja) que se ha introducido en la pila. Las operaciones de pila
son siempre a nivel de palabra (2 bytes). Se muestra a continuación el efecto
de las instrucciones más importantes que trabajan con la pila:
Instrucción Operación de pila

PUSH AX SP=SP-2; [SS:SP]=AL; [SS:SP+1]=AH;
POP AX AL=[SS:SP]; AH=[SS:SP+1]; SP=SP+2;
CALL FAR PTR LABEL SP=SP-2; [SS:SP]=CS(L); [SS:SP+1]=CS(H); SP=SP-2;
[SS:SP]=IP(L); [SS:SP+1]=IP(H);
CALL NEAR PTR LABEL SP=SP-2; [SS:SP]=IP(L); [SS:SP+1]=IP(H);
RET (lejano) IP(L)=[SS:SP]; IP(H)=[SS:SP+1]; SP=SP+2;
CS(H)=[SS:SP]; CS(L)=[SS:SP+1]; SP=SP+2
RET (cercano) IP(L)=[SS:SP]; IP(H)=[SS:SP+1]; SP=SP+2;
3.4.7. Módulo fuente
Un módulo fuente está formado por instrucciones y directivas. Las instruc-

ciones son representaciones simbólicas del juego de instrucciones del procesa-
dor (código máquina). Las directivas indican al ensamblador cierta manera de
proceder a la hora de compilar, asi como para definir segmentos y reserva de
espacio en memoria (variables, pila...). Las instrucciones se aplican en tiempo
de ejecución mientras que las directivas se aplican en tiempo de ensamblaje.
Una constante es un nombre simbólico al que se le asocia un valor, el cual
permanece invariable en el proceso de ejecución del programa. El ensamblador
permite varias formas de representación de las constantes. Los valores numéri-
cos pueden expresarse en base decimal (D), binaria (B), Hexadecimal (H) y
octal (O). Por defecto, la representación se entiende que es decimal. Ası́, 10,
10D, 1010B, 0AH, 12O representan al mismo valor numérico. Los caracteres
alfanuméricos se representan encerrados entre comillas o bien expresando su
código ASCII.
Una etiqueta es un nombre simbólico que acompaña a una instrucción
o a una directiva en el módulo fuente y equivale al valor de la dirección de
memoria donde se encuentra esa instrucción, es decir, la etiqueta “apunta” a
esa posición.
Instrucciones
En el programa ensamblador, las instrucciones del 8086 aparecen con el
formato general:
Etiqueta: Nombre Instrucción Operando(s) ;Comentario
De estos campos, sólo el nombre de la instrucción es obligatorio. En la
sintaxis del ensamblador cada instrucción ocupa una lı́nea. Los campos se
separan entre sı́ por al menos un carácter espacio (ASCII 32) y no existe
distinción entre mayúsculas y minúsculas.
El campo etiqueta, si aparece, debe estar formado por una cadena alfa-
numérica seguida de un identificativo que expresa su atributo. La cadena no
debe comenzar con un dı́gito y no se puede utilizar como cadena alguna pala-
bra reservada del ensamblador ni nombre de registro del microprocesador.
El campo nombre instrucción es un mnemónico de la instrucción del pro-
cesador. Está formado por caracteres alfabéticos (entre 2 y 6).
E1 campo operando indica dónde se encuentran los datos. Puede haber 0,
1 ó 2 operandos en una instrucción. Si hay 2, al primero se le denomina destino
y al segundo fuente y deben ir separados por una coma. Los operandos pueden
ser registros, dirección de memoria o bien valores inmediatos. En cualquiera

de los casos el tamaño debe ser byte o palabra.
E1 campo comentario es opcional y debe comenzar con el carácter ; . Tam-
bién se puede especificar una lı́nea completa de comentario si comienza por ; .
Conjunto de instrucciones
Instrucciones de transferencia de datos. Mueven información entre regis-
tros y posiciones de memoria o puertos de E/S. Pertenecen a este grupo
las siguientes instrucciones: MOV, LEA, IN, OUT, POP, PUSH, XCHG:
1. MOV AX, [VAR1]: (AX ← contenido de la variable VAR1)
2. LEA AX, VAR1: (AX ← dirección de la variable VAR1)
3. IN y OUT: Lectura y escritura en los puertos de E/S
4. PUSH y POP: Escritura y lectura en pila
5. XCHG AX, BX: (AX ↔ BX)
Instrucciones aritméticas. Realizan operaciones aritméticas sobre núme-
ros binarios o BCD. Son instrucciones de este grupo ADD, SUB, CMP,
INC, DEC, NEG, MUL, DIV:
1. ADD AX, BX: (AX ← AX+BX)
2. SUB AX, BX: (AX ← AX-BX)
3. CMP AX, BX: (AX-BX y actualiza los flags)
4. INC AX: (AX ← AX+1)
5. DEC AX: (AX ← AX-1)
6. NEG AX: (AX ← C2[AX])
7. MUL BL: (AX ← AL × BL)
8. DIV BL: (AX ← AX/BL; AH=resto, AL=cociente)
Instrucciones lógicas. Realizan operaciones de desplazamiento, rotación
y lógicas sobre registros o posiciones de memoria. Están en este grupo las
instrucciones: AND, OR, XOR, NOT, SHL, SHR, SAL, SAR, ROL, ROR:
1. AND AX, BX: (AX ← AX∧ BX)
2. OR AX, BX: (AX ← AX∨ BX)
3. XOR AX, BX: (AX ← AX⊕ BX)
4. NOT AX: (AX ← C1[AX])
5. SHL AX,n / SHR AX,n: Desplazamiento lógico a la izquierda/de-
recha de n bits
6. SAL AX,n / SAR AX,n: Desplazamiento aritmético a la izquier-
da/derecha de n bits. El desplazamiento aritmético a la derecha
provoca extensión de signo
7. ROL AX,n / ROR AX,n: Rotación de n bits a la izquierda/derecha

Instrucciones de transferencia de control. Se utilizan para controlar la
secuencia de ejecución de las instrucciones del programa, tales como JMP,
JXX, JNXX, LOOP, CALL, RET:
1. JMP LABEL: Salto incondicional. Salta a la instrucción etiquetada
con LABEL
(IP ← LABEL)
2. JXX y JNXX: Saltos condicionales:
• JE/JNE: Salto si igual/no igual
• JZ/JNZ: Salto si cero/no cero
• JG/JL: Salto si mayor/menor
• JGE/JLE: Salto si mayor-igual/menor-igual
• JC/JNC: Salto si carry/no carry
• JS/JNS: Salto si negativo/no negativo
• JO/JNO: Salto si overflow/no overflow
3. LOOP LABEL: Equivalente a “DEC CX” + “JNZ LABEL”
4. CALL: Salto a subrutina
5. RET: Retorno de Subrutina
Directivas
Las directivas son expresiones que aparecen en el módulo fuente e indican
al compilador que realice determinadas tareas en el proceso de compilación. El
uso de directivas es aplicable sólo al entorno del compilador, por tanto varı́an
de un compilador a otro y para diferentes versiones de un mismo compilador.
Las directivas más frecuentes en el ensamblador son:
Directivas de asignación: Se utilizan para dar valores a las constantes o
reservar posiciones de memoria para las variables (con un posible valor
inicial). DB y DW son directivas que expresan al compilador que reserve
memoria para las variables indicadas. Por ejemplo,
VAR1 DW 5
VAR2 DB ’A’
VAR3 DB 5 DUP (0)
VAR4 DW 2 DUP (5)
La directiva EQU es utilizada para asignar un valor a una constante.

BASE EQU 25
Directivas de segmento: La directiva ASSUME nos indica cuál es el registro

de segmento que se usará para direccionar las etiquetas de un segmento
lógico definido por SEGMENT. Por ejemplo:
ASSUME CS:CODIGO, DS:DATOS, SS:PILA

Para indicar el comienzo y fin de un segmento lógico en un módulo
fuente se utilizan las directivas SEGMENT y ENDS. Un programa tı́pico
consta de las siguientes secciones:
DATOS SEGMENT
;definiciones de variables
D1 DW 1
D2 DB ?
DATOS ENDS
PILA SEGMENT STACK
;reserva de espacio para pila
DB 1024 DUP(0)
PILA ENDS
CODIGO SEGMENT
;instrucciones del código
...
CODIGO ENDS
Directiva de Fin de programa: La directiva END indica al compilador

dónde termina el módulo fuente. Generalmente lleva a continuación la
dirección de memoria en donde se encuentra la primera instrucción que
se debe ejecutar.
END INICIO
La palabra inicio es alguna etiqueta o el nombre de algún proce-

dimiento en el cual se encuentra la primera instrucción a ejecutar en
nuestro programa.
Directivas de operando: Se aplican a los datos en tiempo de compilación.

Actúan sobre los datos para obtener información sobre ellos tales como
OFFSET, que devuelve el desplazamiento de una variable con respecto al
segmento en el que se encuentra. SEG devuelve el segmento en el que se
encuentra una variable. La directiva PTR modifica momentáneamente el
tamaño de una variable para una asignación concreta.
MOV BX, OFFSET VAR1 ; BX <- Dir. de VAR1

MOV AX, SEG VAR1 ; AX <- Segmento de VAR1
INC BYTE PTR [DI] ; Considera el operando
; apuntado por DI de tama~
no BYTE
A tı́tulo ilustrativo se muestra un programa fuente con vistas a ser ejecu-

tado en un entorno MS-DOS (las interrupciones se refieren a los servicios de

este sistema operativo).
CR EQU 13 ; Retorno de carro

LF EQU 10 ; Llena una linea
;-----------------------------------------------------
; Segmento de datos
DATOS SEGMENT
D1 DB 00H, 4CH
D2 DW 2H, 1234H
D3 DD ?
CADENA1 DB ’FUNDAMENTOS DE LOS COMPUTADORES’,CR,LF,’$’
CADENA2 DB ’Dpto. Arquitectura de Computadores’,CR,LF,’$’
DATOS ENDS
;-----------------------------------------------------
; Segmento de pila
PILA SEGMENT STACK
DB 512 DUP (’?’)
PILA ENDS
;-----------------------------------------------------
; Segmentos de código
CODIGO1 SEGMENT
ASSUME CS:CODIGO1, SS:PILA, DS:DATOS
INICIO: MOV AX,SEG DATOS
MOV DS,AX
; Escribir texto
CALL CERCANO
CALL FAR PTR ESCRIBIR
MOV AX,[D1]
FIN: INT 21H ; VOLVER AL DOS
CERCANO PROC
LEA DX,CADENA1
RET
CERCANO ENDP
CODIGO1 ENDS
;-----------------------------------------------------
CODIGO2 SEGMENT
ASSUME CS:CODIGO2
ESCRIBIR PROC FAR
PUSH AX ; Salva el registro AX en la pila
MOV AH,9H ; Funcion 9 del DOS
INT 21H ; Llamada a la interrupcion 21
POP AX ; Recupera registro AX
RET ; Vuelta al programa principal
ESCRIBIR ENDP
CODIGO2 ENDS
;-----------------------------------------------------
END INICIO
SINOPSIS
En este tema hemos profundizado un poco más en el funcionamiento de un

procesador. Hemos descrito los Registros, la Sección de Procesamiento y la
Sección de Control, a modo de introducción para los dos siguientes temas. Por
otro, lado hemos visto los conceptos de subrutina, interrupción y pipeline de
instrucciones. Por último, se ha descrito un procesador comercial como el 8086
de Intel y hemos introducido ası́ la programación en ensamblador.
1. Para el número de 16 bits: 1001 0101 1100 0001 almacenado en el registro

AX, muestra el efecto de:
a) SHR AX, 1
b) SAR AX, 1
c) SAL AX, 1
d) ROL AX, 1
e) ROR AX, 1
2. ¿Cómo podrı́as poner a 0 el registro AX si no dispones de una instrucción
de BORRAR (CLEAR)?
3. Inventa un método para intercambiar dos registros (AX y BX) sin usar
un tercer registro o variable ni la instrucción XCHG. Sugerencia: piensa
en la instrucción OR EXCLUSIVO.
4. Tenemos 250 números en C2 de 16 bits en las posiciones 500 a 998 de
memoria. Escribir un programa en ensamblador del 8086 que cuente los
números P ≥ 0 y N < 0 y que almacene P en la posición 1000 de
memoria y N en la 1002.
5. Tenemos 100 números positivos de 16 bits en las posiciones de memoria
1000 a 1198. Escribir un programa que determine cuál es el número
mayor de todos y lo almacene en la posición 1200.
6. Escribir un procedimiento en lenguaje ensamblador del 8086 que calcu-
le N! y lo almacene en la posición de memoria 502. Supondremos que
1<N<255, que el número N está en la posición 500 de memoria y que
N! cabe en un registro de 8 bits.
7. Escribir una subrutina en lenguaje ensamblador que convierta un entero
binario positivo (menor que 1000 y almacenado en la posición 2000 de
memoria) a ASCII, guardando cada carácter a partir de la posición 3000
de memoria. Por ejemplo, el número 345 debe traducirse a los caracteres
ASCII 3, 4 y 5 (33H, 34H y 35H en hexadecimal respectivamente)
8. a) Escribe el diagrama de flujo y el programa en ensamblador del 8086
de Intel para el algoritmo que realiza la siguiente función:
Dada una tabla en la posición 100 de memoria con 50 núme-
ros de 16 bits en complemento a dos, multiplicar por 2 los
números pares y dividir por 2 los impares (división entera),
dejando cada número modificado en la misma posición de
la tabla en la que estaba. No utilizar las instrucciones MUL
y DIV. No considerar el caso de overflow al multiplicar por
dos.
b) ¿Qué diferencia hay entre los desplazamientos lógicos y aritméticos

a la derecha?
9. Escribe el diagrama de flujo y el programa en ensamblador del 8086 de
Intel para el algoritmo que realiza la siguiente función:
Dada una tabla en la posición 500 de memoria con 50 números
de 16 bits en complemento a dos, forzar a cero los números ne-
gativos y multiplicar por tres los positivos, dejando cada número
modificado en la misma posición de la tabla en la que estaba. No
utilizar ninguna instrucción de multiplicar (MUL). No considerar
el caso de overflow al multiplicar por tres.
10. Suponga que el contenido de la memoria de un sistema basado en el
i8086 es el que se muestra en la tabla 3.1. El valor de los registros
es: DS=SS=E000H, SI=0001H, DI=0002H, BP=0003H, BX=0004H. Se
define ası́ mismo una etiqueta TABLA, que apunta a la dirección fı́sica
E0001H y que pertenece al segmento de datos.
posición fı́sica contenido

MOV AX, [TABLA] ..... .....
MOV AX, [SI] E0006 DE H
MOV AL, [SI] E0005 BC H
MOV AX, [SI+2] E0004 9A H
MOV AX, TABLA[SI] E0003 78 H
MOV AL, TABLA[SI] E0002 56 H
MOV AH, TABLA[SI] E0001 34 H <-- TABLA
MOV AX, [BP+2] E0000 12 H
MOV AX, [BX+SI] ..... .....
MOV AX, [BP+SI] 5D276 07 H
MOV AL, [BP+SI+1] 5D275 06 H
MOV AH, TABLA[BX][SI] 5D274 05 H
LEA AX, TABLA 5D273 04 H
LEA DI, TABLA[SI+1] 5D272 03 H
MOV AX, SEG TABLA 5D271 02 H
MOV CX, OFFSET TABLA 5D270 01 H
..... .....
Tabla 3.1: Programa que se analiza y contenido de la memoria
Para cada una de las instrucciones mostradas, determina como que-

dan afectados los registros correspondientes.
11. Sea el siguiente segmento de datos perteneciente a un programa escrito

para el i8086:
DATOS SEGMENT
I DB ’DEPARTAMENTO de ARQUITECTURA de COMPUTADORES’
II DD 00200020H,1H
III DQ 0B
IV DB ’1’,’2’,’3’
V DW ?
DATOS ENDS
a) Suponiendo que la primera posición fı́sica en memoria de dicho
segmento es la 43210H, calcule las posiciónes fı́sicas y lógicas de
cada una de las etiquetas (variables) que componen el segmento.
b) Haga un esquema de cómo quedan almacenados en memoria los
datos.
12. El siguiente programa ensamblador para el i8086 fue ensamblado y eje-
cutado con éxito:
LF EQU 10
CR EQU 13
A25 EQU 25h
A26 EQU 26h
LP EQU 512
DATOS SEGMENT
F DW 25
G DW 80
H DD ?
MUTEX DB 0
DATOS ENDS
PILA SEGMENT STACK
DB LP DUP (0)
PILA ENDS
CODIGO1 SEGMENT
ASSUME CS:CODIGO1, SS:PILA, DS:DATOS
INICIO:MOV AX,DATOS
MOV DS,AX
CALL FAR PTR FILL_INI
WW : CMP BYTE PTR [MUTEX],01H
IN MUTEX,3F8H
JNE WW
MOV AX,F
PUSH AX
MOV AX,G
PUSH AX
CALL FAR PTR FILL_IN
fin: MOV AH,4CH
INT 21H
CODIGO1 ENDS
CODIGO2 SEGMENT
ASSUME CS:CODIGO2, DS:DATOS, SS:PILA
FILL_IN PROC FAR
PUSH BP
MOV BP,SP
LEA SI,[BP+8]
LEA DI,[BP+6]
MOV AX,SS:[SI]
MOV DH,AL
MOV AX,SS:[DI]
MOV DL,AL
MOV AH,06H
INT 10H
POP BP
RET
FILL_IN ENDP
FILL_INI PROC FAR
MOV BYTE PTR H,33H
RET
FILL_INI ENDP
CODIGO2 ENDS
END INICIO
a) Muestre la evolución de la pila del programa indicando qué valores
(o qué registros) van ocupando las posiciónes de ésta. (Al comenzar
la ejecución del programa AX, BX, CX, DX, BP se suponen cero y
SP vale la longitud de la pila)
b) Explique los modos de direccionamiento que aparecen en el progra-
ma.
c) Si las rutinas FILL IN, FILL INI hubieran estado en el mismo seg-
mento que el programa principal, se podrı́an haber invocado como
etiquetas cercanas (CALL (NEAR PTR) ...). ¿De qué manera afecta
ésto a la ejecución del programa?
13. Las siguientes cuestiones están referidas al procesador Intel 8086:
a) Los dos fragmentos siguientes de programa ensamblador realizan
una operación sobre los registros AX, BX, CX, cuyo resultado nu-
mérico es el mismo. ¿Cuál se espera que se ejecute en menos tiem-
po? ¿Por qué razones? ¿Qué instrucciones podrı́an ser eliminadas
directamente sin modificar la semántica del código?
PUSH AX MOV CL,CH

PUSH BX MOV CH,BH
ADD BH,AH ADD CH,AH
MOV CL,BH CMP CL,CH
POP BX JE FIN
FIN: POP AX FIN: ROL CX,08H
(a) (b)
b) No obstante ambos fragmentos no modifican de igual forma el indi-
cador de acarreo final CF. Suponiendo que AX=F0A0H, BX=0F70H,
CX=8001H, antes de la ejecución, calcula cuánto vale CF y los re-
gistros (en hexadecimal) AX, BX, CX al terminar la ejecución de
los dos códigos. Suponemos que sólo las instrucciones ROL y ADD
afectan potencialmente al bit de acarreo, en su ejecución. 5 (Justifi-
car resultados)
AX=
BX=
CX=
CF(a)=
CF(b)=
5
Recuerda que el 8086 realiza las operaciones aritméticas en complemento a dos y debes
usar el convenio del fabricante para rotaciones y desplazamientos si procede.
4
Sección de Control
OBJETIVOS
Presentar una técnica para el diseño de una Sección de Control micro-

programada
Aprender a codificar microsubrutinas asociadas a instrucciones máquina
CAPÍTULO 4: SECCIÓN DE CONTROL 73
4.1. INTRODUCCIÓN. CONTROL CABLEADO VER-

SUS MICROPROGRAMADO
Como se ha visto en el capı́tulo 3, la función de una sección de control es

generar las señales necesarias para el funcionamiento del sistema en el estado
de control actual y para determinar cuál es el siguiente estado de control. Estas
operaciones las realiza en función del código de operación (C.O.) y el modo de
direccionamiento (MD) de la instrucción que hay en el registro de instrucción
(RI), cargada previamente desde la memoria principal.
Normalmente, la ejecución de una instrucción simple causa más de un
cambio de estado en el sistema computador, enviándose, para cada uno de
ellos, un grupo de señales de control a las unidades del sistema. Cada grupo
de señales causa la ejecución de unas operaciones básicas especı́ficas (deno-
minadas microoperaciones), tal como la transferencia entre dos registros, el
desplazamiento de los contenidos de un registro, o la selección de la función
a realizar por la ALU. El siguiente grupo de señales de control puede o no
depender de los resultados de la presente microoperación, o del estado de cier-
tos flags del sistema6 . De esta manera, la interpretación y ejecución de una
(macro)instrucción da lugar a una secuencia de operaciones máquina básicas
(microoperaciones), cada una controlada por un grupo especı́fico de señales de
control (o microinstrucción).
La tarea principal de la unidad de control será secuenciar las microopera-
ciones, estableciendo en cada ciclo el estado de control actual (y siguiente) y
generar las microinstrucciones precisas para la ejecución de la macroinstruc-
ción. Por consiguiente, la sección de control debe contener la lógica necesaria
para el almacenamiento de la información que identifica al estado de control
actual y la lógica de decisión para la generación del identificador del estado
de control siguiente. El identificador de estado actual puede estar conectado
directamente a los puntos de control de la sección de procesamiento, o, más
habitualmente, ser transformado mediante una lógica de decodificación en una
plantilla que activa las señales de control.
La unidad de control cableada, cuyo diagrama básico de bloques se muestra
en la figura 4.1, está compuesta por un conjunto de dispositivos de almace-
namiento MSI (registros), para almacenar el estado de control actual y un
conjunto de bloques combinacionales MSI (decodificadores) y SSI (puertas
discretas), para generar el identificador de estado siguiente y las señales de
6
En otras palabras, la siguiente microoperación será determinada en función de la mi-
crooperación actual y en algunos casos del estado de ciertos flags.
control. Tı́picamente, el diseño de este dispositivo se hace mediante la apli-

cación de heurı́sticos, de forma que, en principio, no existe una metodologı́a
precisa y concreta para su implementación. Una sección de control de este tipo
suele ser (salvo para sistemas muy simples) poco flexible y estructurada, de
forma que una modificación de su función requiere normalmente el rediseño
parcial o total de la unidad.
SEÑALES
DE
CONTROL
cn
DECOD
.....
LOGICA
DE c5
LOGICA DE GENERACION LOGICA DE IDENTIFICACION
CK DEL SIGUIENTE ESTADO DEL ESTADO DE CONTROL
DECOD. c4
(opcional) c3
DE CONROL ACTUAL
c2
c1
CONDICIONES FLAGS
Figura 4.1: Unidad de control cableada
Frente a esta alternativa clásica, la unidad de control microprogramada,

cuyo diagrama de bloques se muestra en la figura 4.2, utiliza un bloque de
memoria LSI (ROM, PROM, PLA), llamado memoria microprograma.
SEÑALES
DE
CONTROL
Proyector del cn
Codigo de Operación
.....
LOGICA
microinst. DE c5
Secuenciador de Microprograma direcc. Memoria de Microprograma
CK
DECOD. c4
(Genera la siguiente dirección) (Almacena microinstrucciones) c3
c2
c1
Información sobre la dirección siguiente
CONDICIONES FLAGS
Figura 4.2: Unidad de control microprogramada
Esta memoria almacena la información del estado de control actual, que es-
tará identificado por la dirección seleccionada en dicha memoria. El contenido
de esta posición será la microinstrucción a ejecutar y suministra la informa-
ción necesaria para generar las señales de control y para que el secuenciador
de microprograma determine la dirección de la siguiente microinstrucción a
ejecutar.
El concepto de microprogramación fue propuesto en 1951 por Maurice
Wilkes. Aunque conceptualmente la unidad de control microprogramada era
mucho más flexible y estructurada que la cableada, la microprogramación no
se empezó a usar comercialmente hasta 1964, con la serie System/360 de IBM.
La razón es que los tiempos de acceso en las memorias ROM disponibles hasta
entonces eran tan altos que la pérdida de prestaciones en los sistemas micro-
programados era inaceptable para usos prácticos.
A partir de finales de los 60 y principios de los 70, el desarrollo de memorias
de semiconductor rápidas y baratas permitió la expansión de la microprogra-
mación a los minicomputadores, generalizándose su uso. Adicionalmente, el
uso de memorias RAM para contener microprogramas posibilitó el diseño de
sistemas microprogramables dinámicamente, en los que el programa de con-
trol puede ser cambiado durante el funcionamiento simplemente cambiando
los contenidos de la memoria microprograma.
En la actualidad, el uso del control microprogramado es generalizado en
los microprocesadores de juego de instrucción complejo (CISC). Sin embargo,
en el diseño de procesadores de juego de instrucción reducido (RISC), en los
que el control es relativamente simple, se prefiere el uso de unidades de control
cableadas, con el fin de optimizar al máximo las prestaciones del hardware y
reducir en lo posible el tiempo medio de ejecución de una instrucción (es decir,
bajar el CPI – ciclos de reloj por instrucción–).
Puede resultar confuso y quizás poco didáctico intentar definir desde el
primer momento los conceptos relativos a la microprogramación. Por ello, in-
tentaremos hacer una primera aproximación a estos conceptos mediante un
ejemplo para posteriormente adentrarnos más en detalle en temas avanzados.
De acuerdo con esta filosofı́a, comenzaremos describiendo el flujo de datos
de un hipotético procesador simple. A continuación, ilustraremos la técnica
de control microprogramada mediante el desarrollo paso a paso de la sec-
ción de control microprogramada que controle a la sección de procesamiento
inicial. Finalmente, se introducirá un conjunto de conceptos más complejos,
relacionados con la temporización, optimización del diseño, y generación de
microsubrutinas asociadas a instrucciones máquina.
4.2. DISEÑO DE UNA UNIDAD DE CONTROL MICRO-

PROGRAMADA
Se desea diseñar una unidad de control microprogramada para la sección de

procesamiento elemental de la figura 4.3. Esta sección está compuesta por re-
gistros de 8 bits (DR, AC, IR, PC, MAR), una ALU con operandos y resultado
de 8 bits, multiplexores y buses de 8 bits para interconectar estos elementos.
RAM
C3 W (CS)
C4
8 8
8
1 0
MUX C6
C7
DR C5
BUS
Z L R C0
C
ALU C1 1 0
C2 C14 C12
MUX C8
1 0
C16 C9
MUX C10
IR PC MAR
C11 C13
(inc)
AC C15 (right shift)
Figura 4.3: Una hipotética sección de procesamiento elemental
Es importante aclarar que aunque existe un bloque de memoria RAM en

la figura, éste no pertenece a la sección de procesamiento (sino a la unidad
de memoria del computador). En dicha memoria principal se almacenarán las
instrucciones y los datos que procesará la sección de procesamiento.
Para simplificar el proceso de diseño, las entradas de control de los diversos
componentes han sido abstraı́das por conmutadores conceptuales, numerados
del 0 al 16 (c0-c16), y situados en las puertas de entrada y salida de los

registros, estando cada conmutador controlado por una única lı́nea de control.
Un conmutador a la entrada de un registro la habilita cuando su lı́nea de
control pasa de 0 a 1 (es decir, es activo en flanco de subida) y permanece
activado sólo un breve intervalo de tiempo, suficiente para que el dato sea
almacenado en el registro. Un conmutador a la salida de un componente se
activa cuando su lı́nea de control pasa a valer 1 y permanece activado hasta
que la lı́nea vuelve a cero (es decir, es activo por nivel).
Aquellos registros que posean una salida conectada a un bus compartido
poseerán capacidad tri-estado en dicha salida; si por el contrario el bus le
está enteramente dedicado, la salida no poseerá esta capacidad.
El direccionamiento y acceso a memoria se realiza a través de los registros
MAR y DR. El registro MAR posee una salida sin capacidad tri-estado, a
través de la cual el contenido del registro MAR se usará como dirección a
acceder en la memoria. Por su parte, la entrada del registro DR está controlada
por un multiplexor: si la lı́nea de control c6 está a 0, la entrada al registro DR
será el contenido del bus de datos de la memoria; si, por el contrario, la lı́nea
c6 está a 1, el registro DR recibirá la información contenida en el registro
AC. El registro MAR es denominado registro de dirección de memoria,
mientras el registro DR se denomina registro de dato de memoria.
El punto de control c4 habilita el acceso a memoria. En lectura (c3=1),
deja el dato en el bus de datos mientras c4 esta a uno (nivel). En escritura
(c3=0), es en el flanco de bajada de c4 cuando se escribe el dato en la posición
de memoria contenida en el registro MAR.
En la tabla 4.1 se sumariza la función de cada uno de los conmutadores
del diseño.
Los diseños como los de la figura 4.3 son más un producto de la intuición y
la experiencia que de la aplicación de un conjunto preestablecido de principios
de diseño. Esto es, no existe una metodologı́a exacta que nos diga que, para un
conjunto de instrucciones dados y unos objetivos de rendimiento establecidos,
el diseño de la sección de procesamiento es la elección óptima.
El siguiente paso del diseño consiste en conseguir que esta sección de pro-
cesamiento haga algo útil. Para ello, crearemos una sección de control mi-
croprogramada que, para cada instrucción del conjunto de instrucciones del
procesador que estamos construyendo, genere una secuencia de conjuntos de
señales que, ordenadamente, vayan activando los puntos de control pertinentes.
Comenzaremos por introducir un registro de control (o registro de mi-
croinstrucción –MicroRI–), de 17 bits de anchura, en el que cada bit esté co-
C Significado C Significado
c0 Selección ADD en ALU c1 Selección AND en
ALU
c2 Selección COMP de la entrada L c3 Read(R) / Write(W )
de la ALU (C1)
c4 Habilitación memoria c5 MEM ← DR
c6 0:(DR ← MEM), 1:(DR ← AC) c7 Escritura en DR
c8 0:(MAR ← DR), 1:(MAR ← PC) c9 Escritura en MAR
c10 0:(AC ← DR), 1:(AC ← ALU) c11 Escritura en AC
c12 PC ← DR c13 INC PC
c14 IR ← DR c15 Desplaza a la derecha
AC
c16 Carga registro de estado (C,Z)
Tabla 4.1: Funciones de los conmutadores de control
nectado a una única lı́nea de control, tal como se muestra en la figura 4.4.
MicroRI
c0 c2 c3 c16
Figura 4.4: Registro de control
El problema ahora es el siguiente: colocar un valor en el registro de control,

¿desde dónde? Una segunda consideración a tener en cuenta es que el poner un
único valor no será suficiente; realmente necesitaremos un conjunto de valores
que varı́e en el tiempo, de manera que una secuencia preestablecida de valores
de control vaya apareciendo en el registro de control en intervalos periódicos.
Para conseguir esto, ya imaginamos las dos alternativas básicas:
Diseño de un dispositivo secuencial (máquina de estados) formado por
puertas lógicas, biestables, contadores, etc..., que dilucide en cada mo-
mento (en función del estado en el que se encuentre) qué valor debe al-
macenarse en el registro de control y a qué próximo estado debe cambiar.
Esta solución es la que ya habı́amos identificado en la sección anterior
con el control cableado.
Ya que tenemos que definir una secuencia de valores de 17 bits a al-
macenar en el MicroRI, ¿por qué no almacenamos estos valores en otra
memoria (distinta de la memoria principal de la figura 4.3) y cada vez
que necesitemos una palabra de control (microinstrucción) la leemos de
dicha memoria? Esta solución conduce al diseño de una sección de con-
trol microprogramada como la de la figura 4.5.
Memoria
INC Contador de
Microprograma
CK
STORE
MicroRI
c0 c2 c3 c16
Figura 4.5: Sección de control microprogramado inicial
En la figura 4.6 vemos como el registro MicroRI se conecta a una Memoria

de Microprograma (también llamada memoria de control, micromemoria o
µMem.), direccionada por medio de un contador. El registro MicroRI tiene
una señal Store (activa por flanco de subida). Por su parte, el contador tiene
una entrada INC, activa en una transición de 0 a 1 (flanco de subida), que le
hará incrementar en uno su valor actual.
Evidentemente, será también necesario un reloj, CK, que permita realizar
la sincronización necesaria para ir leyendo periódicamente las microinstruc-
ciones de la Memoria de Microprograma y almacenándolas en el MicroRI.
Inicialmente se considerará un esquema de control muy simple, en el cual la
señal de reloj se conectará directamente a la entrada Store del registro MicroRI
y la misma señal invertida atacará el punto de control del registro Contador,
como vemos en la figura 4.6. Por tanto, en cada flanco de subida del ciclo de
reloj, el contenido de la memoria apuntado por el registro Contador se cargara
en MicroRI y en el flanco de bajada se incrementará el Contador.
Llegados a este punto daremos unas cuantas definiciones:
A este periodo de reloj se le denominará tiempo del ciclo máqui-
na y será el intervalo entre conjuntos sucesivos de señales de control
suministradas a la sección de procesamiento.
Cada palabra de 17 bits de la memoria de control recibe el nombre de mi-
croinstrucción. Por consiguiente, una microinstrucción es un conjunto
de señales de control o especificaciones que controla el flujo de datos y
las funciones del dispositivo en la sección de procesamiento durante un
Memoria
INC
Contador de
Microprograma
17
STORE
MicroRI
c0 c2 c3 c16
CK
Figura 4.6: Sección de control microprogramado más detallada
ciclo máquina.
La colección de microinstrucciones almacenadas en la memoria se deno-
mina microprograma. La memoria que contiene el microprograma se
denomina memoria de microprograma, mientras el contador que la
direcciona actúa como un secuenciador de microprograma muy primitivo
que también llamaremos contador de microprograma o MicroPC.
4.2.1. Caracterı́sticas temporales

Un primer examen de la unidad de control diseñada, rápidamente revela que el
sistema no funciona, debido a que no se ha tenido en cuenta la temporización
en el uso de los recursos del procesador.
Un problema que se plantea es el hecho de que no hay ningún mecanismo
que garantice que las señales de control asociadas a interruptores activos por
flanco pasen a 0 tras haber tomado el valor 1 y, por tanto, que garantice
la aparición del flanco de activación. Por ejemplo, si dos microinstrucciones
sucesivas son del tipo:
XXXXX XXXX1 XXXXX XX
XXXXX XXXX1 XXXXX XX
el 1 de la segunda microinstrucción no tendrá ningún efecto. Esto es debido
a que ese punto de control, c9, se activa por flanco de subida, de forma que
fuerza la carga del registro MAR cuando pasa de 0 a 1. Por tanto, la primera
microinstrucción si tendrá el efecto esperado 7 , pero la segunda no, ya que que
en principio no existe ninguna transición baja-alta.
Es evidente, pues, que es necesario secuenciar la generación de diferentes
conjuntos de señales de control dentro del ciclo máquina. Una solución simple
que adoptaremos para el ejemplo que estamos desarrollando, en el que dis-
ponemos de una única señal de reloj, es emplear el flanco de bajada de ésta
para temporizar las señales activas por flanco, de manera que si un bit del
MicroRI asociado a un punto de control por flanco esté activo, se produzca
una transición baja-alta con el flanco de bajada del reloj. Los cronogramas
mostrados en 4.7 muestran la situación que deseamos implementar.
CK
n-1 Microinstrucción n n+1 MicroRI
bit i Ci (nivel)
bit j Cj (flanco)
n n+1 MicroPC
Figura 4.7: Formas de onda de las señales en el tiempo
Escribiendo ciertas ecuaciones lógicas para los puntos de control del sis-
tema se puede diseñar un circuito que permita crear la secuencia descrita
anteriormente. Ello se consigue fácilmente realizando una operación AND de
los bits que corresponden a señales por flanco en MicroRI con CK tal como se
esquematiza en la figura 4.8.
4.2.2. Ejemplos de microprograma

Una vez solucionada la temporización del ciclo máquina, ya es posible ejecutar
en el procesador un pequeño microprograma. Veamos algunos ejemplos que nos
servirán más adelante en la microprogramación del conjunto de instrucciones
del procesador.
AC ← M em(DR) Carga de AC con el contenido de la posición apun-

tada por DR. Para ello tenemos que llevar la dirección al registro MAR,
7
siempre que la microinstrucción anterior tenga c9=0
CK
Memoria
INC Contador de
Microprograma
STORE
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
C0 C1 C2 C3 C4 C5 C6 C8 C10
C7 C9 C11 C12 C13 C14 C15 C16
Figura 4.8: Esquema parcial de las conexiones de temporización
leer desde memoria en DR y de ahı́ al registro AC.

c0 c4 c8 c12 c16
1.MAR <- DR 0000 0000 0100 0000 0 (activos: c9)
2.DR <- Mem(MAR) 0001 1001 0000 0000 0 (activos: c3,c4,c7)
3.AC <- DR 0000 0000 0001 0000 0 (activos: c11)
M em(DR) ← AC Cargar en la dirección de memoria apuntada por DR

el contenido del acumulador AC. Como en el caso anterior la dirección
destino se guardará en MAR, el acumulador se guarda en DR y DR se
escribe en memoria.
c0 c4 c8 c12 c16
1.MAR <- DR 0000 0000 0100 0000 0 (activos: c9)
2.DR <- AC 0000 0011 0000 0000 0 (activos: c6,c7)
3.Mem(MAR) <- DR 0000 1100 0000 0000 0 (activos: c4,c5)
DR ← DR/2 Dividir el contenido de DR por dos. Para ello trasladamos

el contenido de DR a AC, desplazamos a la derecha AC y el contenido
de AC se volcará en DR.
c0 c4 c8 c12 c16
1.AC <- DR 0000 0000 0001 0000 0 (activos: c11)
2.Shift_Right(AC) 0000 0000 0000 0001 0 (activos: c15)
3.DR <- AC 0000 0011 0000 0000 0 (activos: c6,c7)
4.2.3. Capacidad de salto

Otro importante defecto del diseño, relacionado con el secuenciamiento de
la unidad de control, es la falta de capacidad de ramificación en el micro-
programa, que obliga a pasar secuencialmente por todas y cada una de las
microinstrucciones contenidas en la memoria de control. Un segundo proble-
ma de la unidad de control, es la ausencia de un mecanismo que permita tomar
decisiones en el microprograma, es decir, dar saltos condicionados al valor de
una o más variables de estado de la sección de procesamiento.
Ambos problemas expresan la necesidad de incluir algún procedimiento
que permita la modificación, condicional o incondicional, del contenido del
contador de microprograma. En una aproximación simple, suponiendo que la
memoria de control tiene 64 palabras, se ampliará la microinstrucción con dos
campos más. Uno de estos campos, al que se llamará dirección de salto, tiene
6 bits, y su función es contener la dirección de una palabra de la memoria de
control. El otro campo, que llamaremos de Condición de Salto (o CS) tiene
dos bits, con el siguiente significado:
00 Ejecución secuencial normal. El contador de secuencia se incrementa en
1 y la próxima microinstrucción a ejecutar es la inmediatamente siguiente
a la actual.
11 Salto incondicional. La dirección de la siguiente microinstrucción a eje-
cutar está contenida en el campo dirección de salto de la microinstrucción
en ejecución. El contador se cargará con el valor contenido en los 6 bits
de este campo.
01 Salto condicional asociado al acarreo de salida C de la ALU. Si este
acarreo de salida es 1, la microinstrucción siguiente viene definida por
el campo de dirección de salto como en el salto incondicional. En caso
contrario, la ejecución será secuencial (normal).
10 Salto condicional asociado a la salida Z de la ALU. Si el resultado a la
salida de la ALU es 0 (lı́nea Z a 1), la microinstrucción siguiente viene
definida por el campo de dirección de salto de la actual microinstrucción
como en el salto incondicional. En caso contrario, la ejecución será se-
cuencial (normal).
Para implementar esta capacidad de salto (condicional o incondicional) de
la sección de control podemos utilizar el hardware de la figura 4.9. Los bits
17 y 18 de la microinstrucción forman la microfunción de control de salto,
mientras los bits 19 a 24 constituyen el campo de la dirección de salto.
Vemos como hemos ampliado la funcionalidad del Contador de micropro-
grama (MicroPC a partir de ahora), de forma que además de ser incrementado,
00
0 M
C 01
U
10
LOAD
MicroPC Memoria
Z X INC
de
1 11 1
Microprograma
c17 c18 CK
MicroRI Puntos de control CS Direcc. salto.
c0 c1 c16 2 6
c19...c24
Figura 4.9: Sección de control con capacidad de salto
también puede ser cargado con un nuevo valor que llega desde el campo Direc-
ción del MicroRI. El incremento o la carga del MicroPC estará determinado
por las entradas de control INC o LOAD respectivamente, siendo estas entra-
das activas a nivel alto. El incremento del MicroPC está asociado a la ejecución
secuencial, mientras que la carga implicará un salto a nivel de microprogra-
ma. Los dos bits del campo Condición de Salto, CS, seleccionan una de las
entradas del MUX1 de forma que:
CS=00 La entrada 00, alimentada con un 0 lógico, provocará el incremento
del MicroPC. Es decir, ejecución secuencial.
CS=11 La entrada 11, alimentada con un 1 lógico, provocará la carga del
MicroPC. Es decir, salto incondicional.
CS=01 La entrada 01, alimentada con el valor del flag C determinará la
carga o el incremento del MicroPC según C=1 o C=0, respectivamente.
Es decir: salto condicional al flag C.
CS=10 La entrada 10, alimentada con el valor del flag Z determinará la
carga o el incremento del MicroPC según Z=1 o Z=0, respectivamente.
Es decir: salto condicional al flag Z.
Este simple mecanismo de salto permite incrementar notablemente las po-
sibilidades del sistema. A cambio, se incrementa sustancialmente el tamaño

de la microinstrucción. En este sentido, el campo de dirección de salto resulta
especialmente costoso, pues sus 6 bits suponen un incremento de un 35 % en
la longitud de la palabra de control, y sólo se emplea en unas pocas microins-
trucciones.
Como ejemplo microprogramemos la operación JZ DR: saltar a la dirección
apuntada por DR cuando Z=1, en caso contrario incrementar PC, esto es:
Si Z=1 P C ← DR si no P C ← P C + 1
microprograma
c0 c4 c8 c12 c16 c17 c19
c24
1.Si Z=1 goto 4 0000 0000 0000 0000 0 10 000
100
2.PC <- PC+1 0000 0000 0000 0100 0 00 000
000
3.goto 5 0000 0000 0000 0000 0 11 000
101
4.PC <- DR 0000 0000 0000 1000 0 00 000
000
5.siguiente
microinstrucción ...................................
En este ejemplo las operaciones de las microinstrucciones 2 y 3 se podı́an
haber realizado en una sola microinstrucción pero se ha hecho ası́ por claridad.
4.2.4. Microprogramación del conjunto de instrucciones

Una vez diseñados el datapath y el secuenciador de control del procesador
elemental, se podrı́a proceder a la microprogramación de las diversas (ma-
cro)instrucciones de que se quiera dotar a su juego de instrucciones. Es decir,
tenemos que completar el diseño teniendo en cuenta que al fin y al cabo el
procesador que hemos diseñado tiene que ser capaz de ejecutar cualquier pro-
grama que tenga en su memoria principal. Por tanto debe ejecutar cualquier
instrucción del conjunto de instrucciones de este procesador, a través de las
etapas de búsqueda de instrucción, decodificación, cálculo de la dirección efec-
tiva, búsqueda de operandos y ejecución como se explicó en el tema anterior.
Más concretamente, la ejecución de cada instrucción se llevará a cabo median-
te la ejecución de una microsubrutina (o microrrutina) asociada a cada
instrucción máquina.
Se supone que antes de ejecutar el programa, el sistema operativo, habrá co-
locado el programa en memoria y habrá inicializado el contador de programa,
PC, con la dirección de la primera instrucción máquina a ejecutar. A partir de
ahı́, la sección de control será la encargada de ir leyendo las instrucciones que
sean apuntadas por el PC, cargándolas en el IR y ejecutándolas, hasta que el
programa termine y se devuelva el control al S.O.
En cuanto al registro IR, vemos que no es más que un registro que se de-
IR
ROM de
Proyeccion
1 0
c17 MUX2
Memoria
c16
00 de
0 M
01 Microprograma
C U LOAD
Z 10 X INC MicroPC
11 1
FLAGS 1
1 17 20 25
c18 c19 MicroRI Puntos de control P CS Direcc. salto.
2
c0 c1 c2 c16 c17 2 6
c20...c25
Figura 4.10: Sección de control completa
be cargar desde el BUS MEM, con la instrucción que ha seleccionado el PC

en memoria. El código de operación de la instrucción cargada en el IR debe
inicializar el MicroPC de forma que apunte a la primera microinstrucción de
la microsubrutina asociada a dicho C.O. Para encontrar la dirección de una
microrrutina a partir de su C.O. asociado, utilizaremos una tabla implemen-
tada mediante una ROM, (ROM de Proyección). Esta ROM contendrá en
la dirección indicada por el C.O. la dirección de la microrrutina asociada a di-
cha macroinstrucción. Por ejemplo, si el código de operación de la instrucción
ADD es 25 y tiene asociada una microrrutina que está en la dirección 97 de
la Memoria de Microprograma, la posición 25 de la ROM de proyección debe
contener un 97.
Dado que el MicroPC es cargado algunas veces con la dirección que viene
de la ROM de Proyección y otras veces con la que viene del campo Dirección
del MicroRI, utilizaremos el multiplexor MUX2 para seleccionar cuál de las
direcciones será la que actualice el MicroPC. Ello implica añadir un nuevo
punto de control que denominaremos bit de proyección. Por cuestiones de
significado, añadimos este bit inmediatamente antes del campo de condición
de salto, de manera que será c17, pasando c18, c19 a ser los puntos de control
de salto y c20 a c25 los bits de dirección de salto. En la figura 4.10 se muestra
la unidad de control microprogramada completa. En esta figura no mostramos,
por simplificación, la lógica adicional necesaria de temporización, pero no hay

que olvidar que las microordenes son secuenciadas ordenadamente, tal y como
se explicó en la sección 4.2.1.
Retomaremos ahora, una vez completado el diseño del procesador, el pro-
blema de escribir las microrrutinas asociadas a cada una de las instrucciones
máquina. Cualquier microrrutina debe contener las microinstrucciones nece-
sarias para realizar las siguientes funciones:
1. El contenido de la memoria apuntado por el PC debe ser cargado en
el registro RI (búsqueda de instrucción). A continuación y a partir
del C.O. recién cargado en el RI, se debe cargar la dirección inicial de
la microrrutina asociada en el el registro MicroPC (Decodificación).
Además, se incrementará el registro PC para que apunte a la siguiente
palabra de memoria.
2. Es ejecutado el núcleo de la microrrutina: cálculo de dirección efec-
tiva, búsqueda de operando(s) y ejecución.
3. La última microinstrucción de la microrrutina deberá saltar de nuevo al
conjunto de microinstrucciones encargadas de la búsqueda y decodifica-
ción de instrucciones, que procederá a leer de la memoria principal la
siguiente instrucción a ejecutar, volviendo ası́ a comenzar el ciclo.
Dado que la fase de búsqueda y decodificación de instrucciones es común
e independiente de la instrucción en particular que vaya a ser ejecutada, escri-
biremos las microinstrucciones encargadas de dicha misión una única vez en
la memoria de microprograma, por ejemplo, a partir de la posición 0 de esta
memoria. Llamaremos a ese conjunto de microinstrucciones, microrrutina
de búsqueda y decodificación, o, microrrutina de fetching. Al resto de
las fases (cálculo de dirección efectiva, búsqueda de operando y ejecución) lo
llamaremos el núcleo de la microrrutina asociada a una instrucción dada.
Por tanto, cuando se va a ejecutar un programa y el S.O. lo carga en
memoria e inicializa el PC, apuntando a la primera instrucción, también se
debe resetear el MicroPC al valor cero. Una vez completada la inicialización,
se ejecuta la microrrutina de fetching (recordemos que está almacenada a
partir de la posición 0). Ası́, se carga la primera instrucción en el RI y en la
decodificación, la ROM de Proyección proporciona la dirección del núcleo de
la microrrutina asociada al código de operación que se encuentre en RI. Esa
dirección se cargará en el MicroPC, o dicho de otra forma, estaremos saltando
a la posición de la Memoria de Microprograma que contiene dicho núcleo de
la microrrutina. Una vez completada ésta, la última microinstrucción debe
contener un salto a la posición 0 para volver a buscar y ejecutar la siguiente
instrucción máquina.
Supondremos que en esta máquina hipotética, las instrucciones tiene un
tamaño fijo de 8 bits, interpretándose de la siguiente manera: los 3 bits más
significativos corresponden con el código de operación y los 5 menos significa-
tivos no se usan. Es decir:
<---------- 8 bits ---------->
C.OP. No usado
<- 3 -> <---- 5 ---->
Siguiendo las indicaciones marcadas en el apartado anterior, vamos a elabo-
rar el microprograma que se almacenará en la micromemoria y que implementa
el conjunto de instrucciones mostrado en la tabla 4.2.
Mnemónico Descripción C.OP.

LOAD [X] AC ← Mem(X) 000
STORE [X] Mem(X) ← AC 001
ADD [X] Suma: AC ← AC + Mem(X) 010
AND [X] AND lógico: AC ← AC ∧ Mem(X) 011
JMP Salto incondicional: PC ← AC 100
JZ Salta si cero: si Z=1 ⇒ PC ← AC 101
NOT AC ← C1(AC) 110
SHR AC ← 0,AC[7:1] 111
Tabla 4.2: Conjunto de instrucciones de la CPU
Vemos como en total tendremos 8 instrucciones distintas, donde las 4 pri-

meras utilizan direccionamiento directo a memoria, siendo X una palabra de 8
bits que debe estar a continuación del C.O. en la memoria principal. Sin embar-
go las últimas cuatro instrucciones son de 0 direcciones y toman implı́citamente
el operando del registro AC.
El contenido de la micromemoria resultante para estas instrucciones se
muestra en la tabla 4.3.
Sobre este microprograma cabe hacer los siguientes comentarios:
La búsqueda de instrucciones se realiza en las microinstrucciones 0 a 3.
Las instrucciones se hayan en: LOAD: lı́neas 4 a 8; STORE: lı́neas 9 a
13; ADD: lı́neas 14 a 18; AND: lı́neas 19 a 23; JMP: lı́neas 24 y 25; JZ:
lı́neas 26 a 29; COMP: lı́nea 30; SHIFT: lı́nea 31.
Cada instrucción acaba con la microinstrucción goto 0, que retorna a
la búsqueda de instrucción.
La decodificación se realiza en la lı́nea 3, siendo ésta la única microins-
trucción que activa el bit 17 (proyección).
Operación N Microprograma
c0 1 5 9 13 17 18 20 25
------------ búsqueda y dec. -------------------------------------
MAR <- PC 0 0 0000 0001 1000 0000 0 00 000 000
DR <- Mem(MAR) 1 0 0011 0010 0000 0000 0 00 000 000
IR <- DR 2 0 0000 0000 0000 0100 0 00 000 000
PC <- PC+1 3 0 0000 0000 0000 1000 1 11 000 000
----------------- load X -----------------------------------------
MAR <- PC 4 0 0000 0001 1000 0000 0 00 000 000
DR <- Mem(MAR), PC++ 5 0 0011 0010 0000 1000 0 00 000 000
MAR <- DR 6 0 0000 0000 1000 0000 0 00 000 000
DR <- Mem(MAR) 7 0 0011 0010 0000 0000 0 00 000 000
AC <- DR; goto 0 8 0 0000 0000 0010 0000 0 11 000 000
---------------- store X -----------------------------------------
MAR <- PC 9 0 0000 0001 1000 0000 0 00 000 000
DR <- Mem(MAR), PC++ 10 0 0011 0010 0000 1000 0 00 000 000
MAR <- DR 11 0 0000 0000 1000 0000 0 00 000 000
DR <- AC 12 0 0000 0110 0000 0000 0 00 000 000
Mem(MAR) <- DR; goto 0 13 0 0001 1000 0000 0000 0 11 000 000
------------------ add X -----------------------------------------
MAR <- PC 14 0 0000 0001 1000 0000 0 00 000 000
DR <- Mem(MAR), PC++ 15 0 0011 0010 0000 1000 0 00 000 000
MAR <- DR 16 0 0000 0000 1000 0000 0 00 000 000
DR <- Mem(MAR) 17 0 0011 0010 0000 0000 0 00 000 000
AC <- AC+DR; goto 0 18 1 0000 0000 0110 0001 0 11 000 000
------------------ and X -----------------------------------------
MAR <- PC 19 0 0000 0001 1000 0000 0 00 000 000
DR <- Mem(MAR), PC++ 20 0 0011 0010 0000 1000 0 00 000 000
MAR <- DR 21 0 0000 0000 1000 0000 0 00 000 000
DR <- Mem(MAR) 22 0 0011 0010 0000 0000 0 00 000 000
AC <- AC & DR; goto 0 23 0 1000 0000 0110 0001 0 11 000 000
-------------------- jmp -----------------------------------------
DR <- AC 24 0 0000 0110 0000 0000 0 00 000 000
PC <- DR; goto 0 25 0 0000 0000 0001 0000 0 11 000 000
--------------------- jz -----------------------------------------
Si Z=1 goto 28 26 0 0000 0000 0000 0000 0 10 011 100
goto 0 27 0 0000 0000 0000 0000 0 11 000 000
DR <- AC 28 0 0000 0110 0000 0000 0 00 000 000
PC <- DR; goto 0 29 0 0000 0000 0001 0000 0 11 000 000
-------------------- not -----------------------------------------
AC <- NOT(AC) ; goto 0 30 0 0100 0000 0110 0001 0 11 000 000
------------------- shr -----------------------------------------
SH_RIGHT(AC); goto 0 31 0 0000 0000 0000 0010 0 11 000 000
Tabla 4.3: Contenido de la memoria de microprograma

Ası́ pues, propuesto el contenido de la micromemoria, el contenido del

sistema de proyección (la dirección está expresada en binario y la salida en
decimal), que asocia a cada instrucción el comienzo de la microrutina que la
ejecuta, viene dado por:
C.OP. 000 001 010 011 100 101 110 111
Lı́nea 4 9 14 19 24 26 30 31
4.3. DISEÑO AVANZADO
En esta sección se propone un diseño avanzado para una sección de control

asociada a la sección de datos que se muestra en la figura 4.11. Esta sec-
ción está compuesta por cuatro registros (I, A, B y D), un sumador binario
completo, un desplazador y un multiplexor de dos entradas; adicionalmente,
existen dos registros cuyo contenido es siempre cero. Todos estos componentes
están conectados mediante un conjunto de buses. En particular el BUS X
proporciona la entrada a los registros, el BUS MEM. es el bus de datos de
la memoria RAM, el BUS L alimenta la entrada izquierda (Left) de la ALU,
ası́ como el BUS R hace lo propio con la derecha (Right). Aunque la anchura
de los componentes y las vı́as de datos no es importante para el diseño de
la unidad de control, supondremos una anchura de 16 bits. Las entradas de
control de los dispositivos están sumarizadas en la tabla 4.4.
C Significado C Significado
c1 I → BUS L del Sumador c2 A → BUS L del Sumador
c3 B → BUS L del Sumador c4 0 → BUS L del Sumador
c5 B → BUS R del Sumador c6 D → BUS R del Sumador
c7 0 → BUS R del Sumador c8 Sumador → Desplazador
c9 BUS X → I c10 BUS X → A
c11 BUS X → B c12 D-Mpx → D
c13 D → BUS MEM c14 0 → pasa BUS X; 1 → pasa
BUS MEM
c15 Carry de entrada al Sumador c16 1 → Desplazamiento; 0 → No
desplaza
c17 1 → Derecha; 0 → Izquierda c18 Habilitación de Memoria
c19 1 → Lectura; 0 → Escritura
Tabla 4.4: Funciones de los conmutadores de control

MEMORIA
R/W
RAM
c19
BUS X c18
0 1 B
D-Mpx c14 U
c9 c10 c11 S
c12
I A B D M
E
c1 c2 c3 M
BUS L c5 c6 c13
c4
BUS R
00...000 c7
00...000
L R
Z Sumador C
c15
c8
Desplazador L/R c17

SE c16
Figura 4.11: Sección de procesamiento elemental
4.3.1. Caracterı́sticas temporales

En el diseño de la unidad de control propuesta en la sección 4.2 se temporizó las
señales de control mediante un único reloj. Ello impone una gran limitación en
cuanto a la ejecución de una microinstrucción, ya que el número de registros
que puede “atravesar” un dato por cada periodo de reloj es uno, es decir,
en cada periodo de reloj un dato puede ser transferido de un registro a otro
nada más. Sin embargo, nuestro objetivo puede ser más ambicioso y podemos
desear que en un periodo de reloj, esto es, en una sola microinstrucción, se
pueda realizar la transferencia de un dato por un camino que implique más de
un registro.
Podemos, para ello, dividir el ciclo máquina en una secuencia de subciclos,
en los que se carguen una serie de registros, con lo que en un sólo ciclo podamos
trasladar un dato, si quisiéramos, desde la memoria hasta la salida de la ALU.
Esta división podrı́a ser:

Fase 1. Habilitación de la memoria de microprograma y lectura de la mi-
croinstrucción actual.
Fase 2. Carga del MicroRI con la microinstrucción actual.
Fase 3. Habilitación de la salida del MicroRI. Deshabilitación de la memoria
de microprograma.
Fase 4. Si la microinstrucción actual lo requiere, habilitación de los controles
de salida c1 a c7 y c13 y de la selección de memoria principal, c18.
Fase 5. Si la microinstrucción actual lo requiere, habilitación del conmutador
c8 para pasar la salida del sumador al desplazador. Generación de una
transición 0-1 en la entrada INC del contador de microprograma.
Fase 6. Deshabilitación de los conmutadores c1 a c7, c13 y c18. Si la mi-
croinstrucción lo requiere, habilitación del conmutador c16 para realizar
un desplazamiento.
Fase 7. Si la microinstrucción actual lo requiere, habilitación de los conmu-
tadores c9 a c12 para almacenar la salida del desplazador a través del
bus X.
Las señales de control c14, c15, c17 y c19 son señales ası́ncronas (activas
por nivel), pues no inician ninguna acción. En consecuencia, no requieren un
control temporal, bastando con garantizar que tomen el valor deseado desde
el momento en que se habilita la salida del registro MicroRI.
Una posible implementación de esta secuencia podrı́a ser la generación
de 7 pulsos de reloj dentro de cada periodo de 200 ns, para distinguir cada
fase, pero eso implica subir la frecuencia del reloj. Sin embargo, es posible
simplificar el circuito de reloj necesario usando una única señal de reloj para
crear cuatro pulsos temporales (denominados T1 a T4), también de periodo
200 ns, pero desfasados del reloj principal en tal forma que se solapen.
Ésto se puede conseguir mediante una cadena de elementos de retardo
(que pueden consistir simplemente en dos inversores en secuencia). Dado que
la fase de acceso a la memoria de control es, presumiblemente, la más lenta, se
tomará un retardo de 50 ns entre T1 y T2 y 23 ns de retardo entre T2 y T3 y
entre T3 y T4. En la figura 4.12 se muestran las formas de onda resultantes.
El solapamiento de las señales permite discriminar un considerable número de
intervalos temporales, definidos simplemente mediante el producto (AND) y
suma (OR) lógicos de las señales T1 a T4.
Las ecuaciones lógicas para los puntos de control del sistema deben impli-
car la secuencia de siete pasos, como se describirá más adelante. Ası́, según
se vió en dicho esquema de fases, las acciones iniciales deben ser habilitar la
0 50 100 150 200
T1
T2
T3
T4
ns
CK Retardo Retardo Retardo

50 ns 23 ns 23 ns
T1 T2 T3 T4
Figura 4.12: Formas de onda de las señales de tiempo
memoria de microprograma, cargar el MicroRI con la salida de esta memoria

de microprograma, tras un tiempo igual al tiempo de acceso a dicha memo-
ria y, por último, habilitar la salida del MicroRI y deshabilitar la lectura de
la memoria de microprograma. La gestión de la memoria de microprograma
puede hacerse simplemente conectando la señal T 1 AN D T 2 como señal de
control Enable de la memoria de microprograma.
Por su parte, si se supone que el tiempo de acceso de la memoria de mi-
croprograma es de 40 ns, la señal de habilitación de escritura en el MicroRI,
Store, deberá conectarse a T2 y, por tanto, el registro MicroRI se cargará en el
flanco de subida de T2. Por último, puesto que el MicroRI debe proporcionar
las señales de control a la unidad de procesamiento desde ese instante hasta
el final del ciclo máquina, se conectará la habilitación de lectura del MicroRI,
Enable, a la señal T2 OR T4. En la figura 4.13 se representa parte del esquema
de conexionado que permite el secuenciamiento descrito.
El control de los conmutadores c1 a c7, c13 y c18, necesario en las fa-
ses 4 y 6, se logra simplemente realizando el AND de las señales de control
correspondientes con la señal T3. El conmutador c8, que debe abrirse en un
instante posterior, se controla mediante la señal resultante del AND de la lı́nea
de control c8 y de la señal T4.
Por su parte, la operación de desplazamiento debe retardarse hasta que
el registro de desplazamiento haya recibido la información procedente del su-
CK Retardo Retardo Retardo

50 ns 23 ns 23 ns
T1 T2 T3 T4
Memoria ENABLE
T1
T4 INC Contador de T2
Microprograma
STORE
T2 MicroRI
T4 1 8 12 16
ENABLE
T3 T4 T4 T2
c1 c8 c12 c16
Figura 4.13: Esquema parcial de las conexiones de temporización
mador; en este caso, se conectará al conmutador c16 el AND de la lı́nea de

control c16 y de T 2, de forma que el desplazamiento esté controlado por el
flanco de bajada de T2 y, por tanto, ocurrirá (si procede) unos 50 ns después
de la habilitación del conmutador c8.
Finalmente, los conmutadores c9 a c12 deben habilitarse para terminar el
ciclo (fase 7); en consecuencia, para cada una de sus respectivas señales de
control deberá realizarse el AND con T 4, de forma que los registros I, A, B
y/o D almacenarán la información desde el bus X en el flanco de bajada de la
señal T4. La figura 4.14 muestra el diagrama de tiempos de las distintas fases
durante un ciclo máquina del procesador.
En dicha figura, las lı́neas discontinuas indican que el punto de control
asociado se activa sólo si el bit correspondiente vale 1.
Microinstrucción
al MicroRI
Salida del MicroRI
Controles 1-7,13,18
Control 8
Incrementa Cont.
Control 16
Controles 9-12
Controles 14,15,17,19
0 50 100 150 200 ns
Figura 4.14: Diagrama de tiempos del ciclo máquina
4.3.2. Codificación de las microinstrucciones
Hasta este punto, la filosofı́a seguida en el diseño de la microinstrucción ha

sido una filosofı́a que llamaremos horizontal o sin codificación, en la que a
cada bit corresponde una señal de control. Sin embargo, los 19 bits emplea-
dos dan lugar a 524.288 combinaciones diferentes, cantidad mucho mayor que
el número máximo de microinstrucciones distintas que se emplearán previsi-
blemente. Esto significa que la palabra de control contiene una redundancia
considerable. Si el tamaño de la memoria de control es un factor importante en
el coste final del diseño, será necesario reducir el tamaño de la microinstrucción
introduciendo codificación, a costa de reducir la velocidad de ejecución.
La metodologı́a básica consiste en localizar en la microinstrucción grupos
de bits de control que sean mutuamente exclusivos o redundantes y codifi-
carlos. El ejemplo más sencillo son los bits 1 al 4, que controlan cuál de los
registros (I, A, B o cero) depositará su contenido en la entrada izquierda del
sumador, L. Dado que sólo uno de estos cuatro registros puede ser seleccio-
nado simultáneamente, es posible codificarlo usando tan sólo dos bits, de la
siguiente manera:
Código Registro
00 ceros
01 I
10 A
11 B
Para que esta representación funcione, es necesario incluir una lógica de

decodificación entre el registro de microinstrucción y los conmutadores del
datapath. Ası́, por ejemplo, si los bits empleados para codificar el registro
seleccionado son el 1 y el 2, la señal de habilitación del conmutador c1 de-
berá cumplir la ecuación:
c1 = b1 AN D b2 AN D T3
En la figura 4.15 se representa la lógica necesaria para la generación de es-

ta señal. Una lógica de decodificación análoga deberá ser incluida para los
conmutadores c2 a c4.
b1 b2 MicroRI
T3
c1
Figura 4.15: Decodificador de microfunción
Como se observa, al codificar la información contenida en los bits b1 y

b2 del registro de microinstrucción, ahora ninguno de ellos tiene sentido por
separado, sino que significan algo sólo cuando son analizados juntos. A este
conjunto de uno o más bits en una microinstrucción que controlan un frag-
mento del datapath y que sólo tienen sentido al ser analizados juntos, es lo que
habı́amos denominado microfunción o microorden.
Examinando el datapath, es posible reducir aún más el número de bits de
control. Ası́, los conmutadores c5 a c7, que controlan el registro origen en la
entrada derecha del sumador, pueden codificarse con dos bits, quedando una
combinación sin usar. Por otra parte, los conmutadores c9 a c12 controlan
el destino del contenido del bus X. Teniendo en cuenta que no es necesario
almacenar este contenido en más de un registro distinto y que es preciso incluir
un caso en que el bus X no sea almacenado en ningún registro, deberán usarse
tres bits, en los que se puede usar la siguiente codificación de destino:
Código Destino
000 no operación
001 I
010 A
011 B
100 D (hace c14 = 0)
101-111 no usados
La inclusión de un código que no vuelca el contenido del bus X en ningún
registro permite eliminar la necesidad de generar la señal de control para el
conmutador c8, asociado al registro de desplazamiento. En efecto, cuando una
microinstrucción usa el sumador esta señal debe ser 1; sin embargo, cuando
la microinstrucción no usa el sumador, puede también dejarse esta señal a 1
y elegir el código 000 como destino del bus X. En consecuencia, se elimina el
bit de control del conmutador c8, que estará controlado directamente por la
señal de reloj T4.
Existe también redundancia entre los bits 12 a 14 (control de la entrada y
salida del registro D) y los bits 18 y 19 (acceso a memoria y lectura/escritura,
respectivamente). En efecto, en una operación de lectura de memoria (c18 y
c19 a 1), debe habilitarse el conmutador c12, deshabilitarse el conmutador
c13 y ponerse a 1 la lı́nea c14 de selección en el multiplexor D-Mpx. Por el
contrario, en una operación de escritura a memoria (bit 18 a 1, bit 19 a 0) el
conmutador c12 debe permanecer deshabilitado, mientras el c13 deberá habi-
litarse. Teniendo en cuenta que el control del registro D en operaciones que
no involucren a la memoria es efectuado por la microorden destino del bus
X, resulta evidente que los bits 12 a 14 son superfluos, pues el estado de las
señales de control c12 a c14 puede decodificarse de los bits 18 y 19 y de la
microorden del bus X.
Como resumen de las simplificaciones sugeridas, en la tabla 4.5 se mues-
tra la nueva definición de las microordenes, en la que se han reducido las
necesidades de almacenamiento de control en un 37 %; adicionalmente, se ha
reducido de forma significativa las posibilidades de codificar microinstruccio-
nes erróneas o sin significado. El precio a pagar por ello es un aumento de la
lógica de control necesaria y una pérdida de velocidad y posibilidad de funcio-
namiento concurrente. A esta filosofı́a de representación de microinstrucciones
la hemos llamamos vertical o con codificación.
4.3.3. Expansión funcional del “datapath”: ALU

La funcionalidad del datapath empleado hasta ahora como ejemplo es muy
limitada debido al hecho de que la única operación que puede realizar es la
Microorden Bits Caso Función

Entrada izquierda del Sumador 1-2 00 0
01 I
10 A
11 B
Entrada derecha del Sumador 3-4 00 0
01 B
10 D
11 No usada
Carry de entrada al Sumador 5 0 Carry=0
1 Carry=1
Desplazamiento 6-7 00 No desplazamiento
01 Desplazamiento Izq.
10 Desplazamiento Der.
11 No usada
Destino del BUS X 8-10 000 Ninguno
001 I
010 A
011 B
100 D
101-111 No usada
Operación de Memoria 11-12 00 No operación
01 Leer a D
10 Escribir de D
11 No usada
Tabla 4.5: Definición de microinstrucción codificada
suma. Este defecto es fácilmente solventable sustituyendo el sumador binario

completo por una ALU capaz de realizar las siguientes funciones: L + R + C;
L + R + C; L OR R y L AN D R.
Con cuatro posibles operaciones para ejecutar, se necesitarán dos bits para
su selección, c20 y c21, por lo que deberá incrementarse en dos bits el tamaño
de la microinstrucción. En la figura 4.16 vemos que esta ALU también pro-
porciona dos flags de estado, C (carry) y Z (cero), que son almacenados en
un registro de FLAGS. Un bit de control adicional, c22, señalará la carga de
dicho registro.
4.3.4. Capacidad de salto y constantes en la microinstrucción

El campo “dirección de salto” en las microinstrucciones sólo es útil en aque-
llas que supongan un salto en el microprograma, siendo un conjunto de bits
desaprovechados en el resto. No obstante, podemos ampliar la funcionalidad
L R
c20 2 c22
c21 ALU
c5
C
Z
FLAGS
Figura 4.16: Ampliación de la ALU
de las microinstrucciones, permitiendo que, en las instrucciones de no salto, el

contenido de este campo pueda ser usado como una constante (valor) en la mi-
croinstrucción. Para ello, abrimos un camino de datos que permita cargar en la
ALU el contenido del campo “dirección de salto” del registro MicroRI. Este ca-
mino estará controlado con un nuevo punto de control, c23, que se muestra en
la figura 4.17. A este campo le llamaremos desde ahora “dirección/constante”.
Respecto a los esquemas de temporización necesarios para el buen funcio-
namiento de estas unidades de procesamiento y control mejoradas, es necesario
realizar un cambio importante relativo al momento en que se debe cargar el
MicroPC. Es decir, si queremos que en una misma microinstrucción se pueda
realizar una operación aritmética y un salto condicional al resultado de ésta,
tendremos que permitir la carga o el incremento del MicroPC una vez haya
concluido la operación en la ALU y se haya actualizado convenientemente el
registro de FLAGS. Por ejemplo, en la fase 5 de la página 92, en que se habilita
c8 para cargar el registro de desplazamiento con el resultado de la ALU, tam-
bién podemos activar c22 para actualizar el registro de FLAGS si es necesario,
es decir, con el flanco de subida de T4. De esta forma, el incremento o carga
del MicroPC, condicionada al valor de los flags, se puede realizar con el flanco
de bajada de T3 o T4.
4.3.5. Microprogramación del conjunto de instrucciones

Para que el conjunto datapath y sección de control pueda ser usado como un
procesador de propósito general, añadiremos un sistema de proyección a con-
tinuación de IR y un contador de programa PC. De esta forma, el procesador
final, incluida la sección de control, serı́a el mostrado en la figura 4.17, en el
que se muestran todos los puntos de control incluı́dos los adicionales (carga
de constantes,...). Puesto que hemos empleado codificación en la microinstruc-
ción, es necesario usar un decodificador a la salida de MicroRI. El significado

de los bits que componen la microinstrucción se muestra en la tabla 4.6.
Microorden Bits Caso Función
Entrada izquierda 1-2 00 0
del Sumador 01 I
10 A
11 B
Entrada derecha 3-5 000 0
del Sumador 001 B
010 D
011 PC
100 Constante (bits 21-30)
101-111 No usado
Carry de entrada 6 0 Carry=0
al Sumador 1 Carry=1
Desplazamiento 7-8 00 No desplazamiento
01 Desplazamiento Izq.
10 Desplazamiento Der.
11 No usada
Destino del BUS X 9-11 000 Ninguno
001 I
010 A
011 B
100 D
101 PC
110-111 No usada
Operación de Memoria 12-14 000 No operación
001 (A) → D
010 D → (A)
011 (PC) → RI
100 (PC) → D
101-111 No usada
Función de la ALU 15-16 00 Suma (L + R + C)
01 Resta (L + R + C)
10 OR (L OR R)
11 AND (L AN D R)
Carga del Registro 17 0 No modifica el registro
de FLAGS 1 Actualiza el registro
Control de MUX2 18 0 Pasa Dirección de MicroRI
1 Pasa Dirección de ROM
Control de Salto 19-20 00 µPC=µPC+1
01 Salto Condicional si C
10 Salto Condicional si Z
11 µ PC = Dirección
Dir. Salto/Constante 21-30
Tabla 4.6: Definición final de microinstrucción

Sección de 0 Unidad de
M MEMORIA
Procesamiento R/W Memoria
1 Mpx RAM
c19
BUS X c28 c18
B c25 c26
0 1
D-Mpx c14 U
c9 c10 c11 S
c12 PC RI Sección de Control
I A B D M
E ROM de
c1 c2 c3 M Proyeccion
c13 c24
miento con codificación horizontal

c6
CAPÍTULO 4: SECCIÓN DE CONTROL
BUS L c5 1 0
c4
BUS R c27 MUX2
00...000 c7 c23 Memoria
c22
00...000 0 00 de
M
L R 01 Microprograma
c20 2 C U LOAD
c21 ALU Z
10 X INC MicroPC
c15 11 1
c8 FLAGS 1
1 18 21 30
L/R c17 c29 c30 MicroRI CS Direcc. / Cte.
Desplazador
SE c16
2
DECOD. 2
c1 c2 c3 c28
Figura 4.17: Procesador hipotético completo. Secciones de control y procesa-

101
Aclararemos con un ejemplo el problema de escribir una microrrutina aso-

ciada a una instrucción máquina dada para este procesador. Consideremos la
instrucción ejemplo:
AND 25(A),B
Esta instrucción debe almacenar en el registro B el resultado de hacer el
AND lógico entre el contenido de este mismo registro y el contenido de la
posición de memoria apuntada por el registro A más 25. Es decir:
(25 + A) AN D B → B
Dado que el C.O. ocupa la palabra completa de memoria, el desplazamien-
to, 25, del direccionamiento relativo, se almacena en la siguiente palabra. Por
tanto, las microinstrucciones que se deben ejecutar son las siguientes:
1. RI ← (P C): Cargar el contenido de memoria apuntado por el PC en RI,
es decir, búsqueda de instrucción.
2. c27 ← 1; CS = 11; P C ← P C + 1: Decodificación (carga del MicroPC
con la dirección que viene de la ROM de Proyección) e incremento del
PC.
3. D ← (P C); P C ← P C + 1: Extraemos el desplazamiento de la me-
moria (el “25”) e incrementamos el PC para que apunte a la siguiente
instrucción.
4. A ← A+D: Completamos el cálculo de la dirección efectiva sumando
al registro A el desplazamiento previamente almacenado en D.
5. D ← (A): Búsqueda del operando en memoria a partir de su dirección
efectiva almacenada en A.
6. B ← (B AN D D); CS = 11; Dir = 0: Ejecución, realizando el AND
lógico, y salto final a la posición 0, donde se encuentra la rutina de
fetching.
Siguiendo la codificación de las microordenes presentada en la tabla 4.6 y
suponiendo que el núcleo de la microrrutina se almacena a partir de la posición
12 de la memoria de microprograma, tendremos que el contenido parcial de
esta memoria es el siguiente:
Dirección Contenido
^^^^^^^^^ ^^^^^^^^^
00000 00000 00 000 0 00 000 011 00 0 0 00 0000000000
00000 00001 00 011 1 00 101 000 00 0 1 11 0000000000
.
.
00000 01100 00 011 1 00 101 100 00 0 0 00 0000000000
00000 01101 10 010 0 00 010 000 00 0 0 00 0000000000
00000 01110 00 000 0 00 000 001 00 0 0 00 0000000000
00000 01111 11 010 0 00 011 000 11 1 0 11 0000000000
.
La ROM de proyección debe contener la traducción entre códigos de ope-
ración y dirección de microrutina asociada a la instrucción.
Como vemos en este ejemplo, el código de operación de cada instrucción
contiene en este caso información, no sólo de la operación a realizar y del modo
de direccionamiento, sino también de los operandos. Esto implica que, según
nuestro ejemplo, la instrucción AND 10(A), I debe tener una microrrutina
distinta a la descrita anteriormente, con el consiguiente consumo de Memoria
de Microprograma. En diseños más elaborados, el C.O. no ocupará todo el RI,
dejando espacio para especificar los registros que se vayan a acceder, los cuales
serán seleccionados directamente desde el propio RI.
4.4. DISEÑO DE UNA UNIDAD DE CONTROL CABLEA-

DA
El diseño de unidades de control cableadas implica un compromiso entre la

cantidad de hardware usado, su velocidad de operación y el coste de su proce-
so de diseño. Los métodos de diseño utilizados en la práctica son, a menudo,
de naturaleza heurı́stica y ad hoc (no generales, sino orientados al problema
concreto a resolver). Además, estos métodos de diseño no pueden formalizarse
fácilmente, debido al gran número de señales de control necesarias en una uni-
dad de control y a su dependencia con el conjunto de instrucciones particular
que se implementa.
Para ilustrar el problema, consideramos dos aproximaciones simplificadas
y sistemáticas para el diseño de unidades de control cableadas. Estos métodos
son representativos de los que se usan en la práctica, pero son adecuados
únicamente para unidades de control sencillas, tales como las que se pueden
encontrar en controladores no programables o en procesadores RISC. Estas dos
aproximaciones se denominan respectivamente método de los elementos de
retardo y método de los contadores de secuencia.
Vamos a explicar estos métodos sobre un ejemplo, diseñando una unidad
de control para la sección de procesamiento que se presentó anteriormente en

la figura 4.3. Asociada a esta sección se detallaron los puntos de control en la
tabla 4.1 .
Desde el punto de vista del diseño consideraremos que los señales de con-
trol del procesador son activas a nivel alto. No obstante aquellas que actúen
por flanco de subida o bajada sobre el commutador, (carga, desplazamiento,
incremento de registros) tendrán que ser combinada con la señal de reloj.
Consideraremos un repertorio de instrucciones reducido, que se muestra
en la tabla 4.78 .
Mnemónico Descripción
LOAD A Transfiere el contenido de la posición A al acumulador: (A) → ACC
STORE A Transfiere el contenido del acumulador a la posición A: ACC → (A)
ADD A Suma al acumulador el contenido de la posición A: ACC + (A) →
ACC
JMPZ A Salta a la dirección A si el resultado fue cero: si Z : A → P C
Tabla 4.7: Repertorio de instrucciones
Vamos a aplicar los métodos antes citados para la construcción de este pro-
cesador simplificado. En la figura 4.18 se representa el diagrama de flujo del
funcionamiento del procesador. BEGIN representa una señal de inicio. Como se
puede observar la tarea del procesador se divide en dos fases básicas: búsque-
da de instrucción y ejecución. Durante la búsqueda se accede a la posición de
memoria apuntada por el PC y se transfiere ese contenido al registro de ins-
trucción IR. El PC es incrementado apuntando ahora a la siguiente dirección
de memoria. El contenido de IR se decodifica (identificación de a qué instruc-
ción pertenece el código de operación) y según la operación a realizar se ejecuta
una u otra cosa. En la fase de ejecución se busca el operando, se ejecuta la
operación de ALU y/o se almacena datos en memoria según proceda.
4.4.1. Método de los elementos de retardo

En este método se parte del diagrama de flujo de control para crear el cir-
cuito encargado de producir las señales de control. Para ello lo que vamos a
hacer es generar el conjunto de señales necesarias para cada operación ele-
mental (transferencia de registros) que hemos escrito en el diagrama de flujo,
en el orden adecuado. Cada etapa del diagrama de flujo lo denominaremos
microoperación.
8
Con (A) nos estamos refiriendo al contenido de la posición A de memoria
BEGIN
8 bits
N C.OP.
MAR <- PC
N+1 Operando
formato de instrucción fetch

DR<-(MAR) cycle
INC PC
IR<-DR
DECOD OP
MAR<-PC MAR<-PC MAR<-PC MAR<-PC
DR<-(MAR) DR<-(MAR) DR<-(MAR) DR<-(MAR)
INC PC INC PC INC PC INC PC

execution
cycle
MAR<-DR MAR<-DR MAR<-DR
NO
Z?
DR<-(MAR) DR<-ACC DR<-(MAR)
YES
ACC<-DR (MAR)<-DR ACC<-ACC+DR PC<- DR
LOAD A STORE A ADD A JMPZ A
Figura 4.18: Diagrama de flujo a nivel RTL para el procesador de la fig. 4.3
Vamos a introducir un conjunto de señales auxiliares C ji cuyo significado

es: “Cji se activa en un intervalo ti si la señal de control Cj debe estar activa
en ese intervalo”.
Consideremos el problema de generar la siguiente secuencia de señales de
control en los instantes t1 ,t2 ,...,tn :
t1: Activar Cj1;
t2: Activar Cj2;
...
tn: Activar Cjn;
Aquı́ con Cji representamos la activación del punto de control C j en el
instante ti . (¡Cuidado! no todas las señales se activan en todos los instantes;

en cada instante se activarán aquel subconjunto de señales que intervenga en
la transferencia de registros que queramos realizar). En cada ciclo o intervalo
ti se ejecuta una microoperación.
Podemos producir la cadencia de señales de control introduciendo elemen-
tos de retardo (“delay element”) y propagando la señal de activación. Con
este método la translación entre el diagrama de flujo y la sección de control
es directa ya que el diagrama de flujo expresa la secuencia de activación de
los puntos de control. El circuito diseñado tiene esencialmente la misma es-
tructura que el diagrama de flujo. La forma de obtener el circuito a partir del
diagrama de flujo nos la indica unas reglas simples, que se ven en la figura
4.19. A continuación se explican dichas reglas.
1. Cada secuencia de dos microoperaciones sucesivas requiere un elemento
de retardo. Las señales que activan las lı́neas de control se toman di-
rectamente de las lı́neas de entrada y salida del circuito de retardo. Las
señales que activan una misma lı́nea de control C i se unen con una puer-
ta OR cuya salida es Ci . Esta lı́nea puede conectarse al punto de control
que activa (introduciendo la temporización adecuada si fuera preciso).
2. k lı́neas en el diagrama de flujo que se unen a una lı́nea común se trans-
forma en una puerta OR de k entradas, como muestra la figura 4.19
3. Un bloque de decisión (operación de salto condicional) o bifurcación se
implementa con puertas AND, como aparece en la figura 4.19.
No olvidemos que las señales de control ası́ generadas C j pueden necesitar
ser combinadas con la señal de reloj para generar los flancos adecuados cuando
conectemos las señales con la sección de procesamiento.
Aplicando esta filosofı́a el resultado para el procesador que estamos cons-
truyendo es el que se muestra en la figura 4.20.
En este esquema hay que tener en cuenta:
Como se puede observar el código de operación contenido en IR, es de-
codificado para producir 4 señales (LOAD, STORE, ADD, JMPZ) que
nos sirven para escoger qué rama del diagrama de flujo seguir según la
instrucción que represente el código de operación.
Es necesario introducir una señal BEGIN (no aparece en el esquema)
que ponga a cero (CLEAR) todos los elementos de retardo (y ası́ todas
las señales de control) salvo el primer elemento (señalado con ‘∗’) de
retardo que se pondrá a uno (PRESET) cuando comience la ejecución.
Esta señal ası́ mismo debera poner el PC a un valor conocido apuntando
a la primera instrucción a ejecutar (lo más sencillo serı́a iniciarlo a cero).
C1,j
tj C2,j
........ Ck,1
set Ci,j Ci,j Ck,2 ........... Ck
DE .......
C1,j+1 Ck,n
tj+1 C2.j+1
set Ci,j+1 .........
Ck,j+1
....... .......
x x
no
x=1?
yes
Figura 4.19: Transformación entre diagrama de flujo y circuito con elementos

de retardo
Existen señales como C8,4 , C8,10 , C8,16 , C8,22 que no se pueden activar
nunca a la vez ya que pertenecen a “ramas” excluyentes en el flujo de
ejecución. Es por esta razón por lo que se ha usado una numeración para
el segundo subı́ndice diferente, aunque las 4 señales, cuando se activan, lo
harı́an en el intervalo ficticio t4 . (Es decir dentro del ciclo de ejecución de
una instrucción t4 , t10 , t16 , t22 representan el mismo intervalo temporal
real).
Una vez que se posee el circuito que en cada instante genera los C ji ade-
cuadamente, hay que generar las señales de control C j . Como el significado de
Cji es la activación de la señal Cj en el instante ti , los Cj los determinamos
con el OR de todos los Cji que se activan para algún ti . Las ecuaciones que
resultan son las siguientes:
'
Cj = Cji
i
El elemento de retardo (DE), se construye simplemente con un biestable

tipo D activo por flanco (por ejemplo de subida). Construido de esta manera
la señal de reloj de los elementos de retardo debe ser aquella que sincronice
también los puntos de control activos por flanco en la sección de datos. Ası́ por
ejemplo la señal C7 que controla la carga del registro DR debe ser combinada
con la señal de reloj cuando es conectada en el punto de control c7: c7 ≡
C7 · CK; o para el acceso a memoria c3 ≡ C3 + CK ya que cuando se escribe
el dato se almacena en el flanco de subida de c3.
4.4.2. Método del contador de secuencias

Consideremos el circuito de la figura 4.21, que consiste basicamente en un
contador módulo k cuya salida esta conectada a un decodificador k1 . Si la
entrada ENABLE del contador se conecta a un reloj fuente, el contador ira
pasando continuamente por sus k estados. El decodificador genera k señales
pulso Sj en su salida y, además, pulsos consecutivos están separados por un
periodo de reloj, como muestra la figura. Las señales S j dividen el tiempo
requerido para que un contador recorra su ciclo completo en k partes iguales.
A estas señales Sj se les llama señales de fase. Se necesita un flip-flop y dos
lı́neas de entrada para poner en marcha o parar el contador. Un pulso en la
lı́nea BEGIN hace que el contador comience a recorrer sus estados cı́clicamente,
conectando la lı́nea ENABLE del contador al reloj (CK) fuente. Un pulso en
la lı́nea END desconecta el reloj y resetea el contador. Supondremos que la
señal de “reset” del contador es sı́ncrona con la entrada de reloj. El circuito
de la figura 4.21 se llama contador de secuencia y lo representaremos tal como
se indica en dicha figura.
La utilidad de los contadores de control de este tipo radica en el hecho
de que muchos circuitos digitales se diseñan para realizar un número relativa-
mente pequeño de acciones repetidamente.
Cada paso a través del lazo constituye un ciclo de microoperación. Obser-
vando el diagrama de flujo de la figura 4.18 vemos que desde que una instruc-
ción comienza su ejecución, en el caso peor se consumen 9 etapas (longitud
del camino mas largo). Si suponemos que cada etapa puede realizarse en un
periodo de reloj elegido, entonces podremos construir una unidad de control
para esta CPU, partiendo de un simple contador de secuencia módulo 9. Cada
señal Si activara las lı́neas de control que procedan, en la etapa i-ésima.
El diseño del circuito que genera las señales de control se reduce a un com-
binacional que activará cada control C j en función del código de operación,
del contenido del registro de estados y de la etapa (S i ) en la que se encuen-
tre la ejecución. El combinacional, que representamos en la figura 4.22, debe
implementar las ecuaciones lógicas que se muestran:
C0 = ADD · S9
C1 = 0
IR
* DE
C9,1 C8,1
DEC
DE
C3,2 C4,2 C7,2

LOAD ADD
DE STORE JMPZ
C13,3 C14,3
DE
LOAD STORE ADD JMPZ
DE DE DE DE
C8,4 C9,4 C8,10 C9,10 C8,16 C9,16 C8,22 C9,22
DE DE DE DE
C3,5 C4,5 C7,5 C3,11 C4,11 C7,11 C3,17 C4,17 C7,17 C3,23 C4,23 C23
DE DE DE DE
C13,6 C13, 12 C13, 18 C13, 24

not(Z)
Z
DE DE DE
C9,7 C9,13 C9,19
DE DE DE
DE
C3,8 C4,8 C7,8 C6,14 C7,14 C3,20 C4,20 C7,20
C12, 25
DE DE DE
C11,9 C4,15 C5,15 C0,21 C10,21 C11,21

C16,21
Figura 4.20: Señales de control con elementos de retardo

C2 = 0
C3 = S2 + LOAD · S5 + ST ORE · S5 + ADD · S5 + JM P Z ·
S5 + LOAD · S8 + ADD · S8
S5 + LOAD · S8 + ADD · S8
C5 = ST ORE · S9
C6 = ST ORE · S8
S5 + LOAD · S8 + ST ORE · S8 + ADD · S8
C8 = LOAD · S5 + ST ORE · S5 + ADD · S5 + JM P Z · S5 + S1
C9 = S1 + LOAD · S7 + ST ORE · S7 + ADD · S7 + S4
C10 = ADD · S9
C11 = LOAD · S9 + ADD · S9
C12 = JM P Z · S7
C13 = S3 + S6
C14 = S3
C15 = 0
C16 = ADD · S9
RESET = JM P Z · S8 · Z + JM P Z · S7 · Z
Sobre estas ecuaciones podemos comentar:
Su obtención es inmediata a partir del significado de las señales. Ası́ por
ejemplo C3 nos indica que se activa siempre en la segunda etapa, y en
la etapa 5 cuando la instrucción es un LOAD, STORE, ADD o JMPZ,
y en la etapa 8 cuando se trata de un LOAD o un ADD.
Aunque se han expresado de forma que se entienda como se obtienen, las
expresiones son susceptible de simplificación, más aún teniendo en cuenta
que expresiones mutuamente exclusivas siempre ocurren, por ejemplo
LOAD + ST ORE + ADD + JM P Z = 1.
Hay señales que nunca se activan en este conjunto de instrucciones
(C1 , C2 , C15 ).
No todas las instrucciones consumen la 9 etapas. La instrucción JMPZ
consume menos. Por eso hay que introducir la señal RESET (no olvidar
que es sı́ncrona con el reloj). Esta señal se activa sólo para JMPZ, cuya
ejecución finaliza en la etapa 8 si Z está activo (salto) o en la etapa 7 si
Z está inactivo (no salto).
Como se indicó para el método anterior, las señales de control deben ser
combinadas con el reloj en aquellos casos en el que el conmutador de control
funcione por flanco.
BEGIN
J Q count
modulo - K
counter
END reset
K Q
c0 cN
....................
CK
1/K - decoder
RESET
S1 S2 ........................................SK
CK
CN..C0 0 1 2 BEGIN
modulo - K
END
sequence counter CK
S1 RESET
S2 ......................
S1 S2 SK
S3
Figura 4.21: Contador de secuencias módulo k

BEGIN
IR modulo - 9 END
RESET
sequence counter
DEC CK
S1 S2 ................ S9
LOAD
STORE
ADD
C1
JMPZ combinational
C2
circuit
N
................
C16
Figura 4.22: Unidad de control utilizando un contador de secuencias
SINOPSIS
La técnica de control microprogramado permite el diseño de una unidad de

control de forma sistemática y estructurada. En resumen, hemos visto que
básicamente necesitamos incluir dentro de la sección de control un contador

de microprograma, MicroPC, un registro de microinstrucción, MicroRI y
una Memoria de Microprograma, donde almacenamos cada una de las
microrrutinas asociadas a cada instrucción máquina. Además, hemos intro-
ducido la metodologı́a de diseño de unidades de control cableada, usadas en
procesadores RISC.
1. Para la máquina descrita por la figura 4.17 y la tabla 4.6 de la sección

4.3.5, diseñar la microsubrutina asociada a la instrucción máquina BEQ
dir , que carga en el PC el valor dir si el flag Z es igual a 1. La instruc-
ción BEQ dir ocupa dos palabras de memoria (una para el código de
operación y otra para la dirección de salto).
2. Diseñar la microsubrutina asociada a la instrucción máquina MAX A,B
que coloca en el registro B el valor máximo(A,B). El contenido de los
registros A y B será siempre positivo y representado en C2.
3. Ídem para la instrucción EXG A,B que intercambia los valores de los
registros A y B.
4. Sean las secciones de procesamiento y de control microprogramado de la
figura 4.23. Sus elementos más destacados son:
Memoria RAM externa común para datos e instrucciones asociada
a dos registros: uno de direcciones, M AR y otro de datos, DR.
En una operación de lectura se cargará DR con el contenido de la
memoria apuntada por M AR. En escritura, el contenido de DR se
almacenará en la posición de memoria indicada por M AR.
Tres registros de propósito general A, B y T M P , más un registro
a cero (“0”).
Registro de Instrucción (RI): Almacena una instrucción con un
código de operación de 4 bits.
Contador de Programa (PC): Puede ser cargado desde el BUS, vol-
cado al BUS e incrementado.
Unidad Aritmético-Lógica capaz de realizar las 4 operaciones bá-
sicas de suma, resta, producto y división. Dispone de dos flags de
estado: Signo (N) y Cero (Z).
Suponer resueltos los posibles problemas de temporización y el si-
guiente tiempo de respuesta para el hardware:
1 ciclo de reloj para completar la siguiente cadena de operaciones:
“Volcado de alguno de los registros a la ALU”; “Operación ALU 2
“Escritura en alguno de los registros”. La carga en el MicroPC se

realiza al mismo tiempo que la escritura en registros, es decir, al
final del ciclo de reloj.
1 ciclo de reloj para la lectura o escritura del dato almacenado en
DR en la posición de memoria dada por MAR.
1 ciclo para cualquier transferencia entre los registros DR, RI, P C
y M AR a través del BUS.

Se pide:
a) Diseñar la microrrutina de f etch y decodificación. Describirla en
pseudocódigo y detallar el contenido de la memoria de micropro-
grama en binario a partir de la dirección 0.
b) Diseñar las microrrutinas asociadas a cada una de las instrucciones
de la tabla 4.10. Descrı́belas en pseudocódigo y detalla el contenido
de la memoria de microprograma en binario, colocando cada micro-
rrutina a partir de la posición de micromemoria que le corresponda.
Utiliza la tabla 4.9 para escribir las microsubrutinas, utilizando el
campo Comentario para poner en pseudocódigo el significado de
cada instrucción. Suponer que el ciclo de f etch no modifica los flag
de estado.
c) Detallar el número de palabras y el contenido de la ROM de Proyec-
ción teniendo en cuenta el código de operación de cada instrucción
de la tabla 4.10.
SEÑAL Significado
c1, c2, c3 Habilitación de entrada a registros A, B y TMP.
c4 Habilitación de entrada a registro RI.
c5, c6, c7, c8 Habilitación de salida de A, B, TMP y “0” a la ALU.
c9 Control del Multiplexor-1.
c10 Vuelca al BUS el dato de salida de la ALU.
c11, c12 Selecciona la operación al realizar en la ALU:
00=Suma. 01=Resta. 10=Producto. 11=División.
c13 Incrementa el PC.
c14 Carga en PC el dato que haya en el BUS.
c15 Vuelca al BUS el dato almacenado en PC.
c16 Debe estar a 1 cada vez que se utilice la memoria (Chip
Select).
c17 1 = Lectura de memoria a DR. 0 = Escritura en memoria
de DR.
c18 Carga en MAR el dato que haya en el BUS.
c19 Carga en DR el dato que haya en el BUS.
c20 Vuelca al BUS el dato almacenado en DR.
Tabla 4.8: Puntos de control especificados (Prob. 4)

c1 c2 c3 c4
A B TMP "0"
RI
c5 c6 c7 c8
c16 c17
ROM de
c18 Proyeccion
CS RD/WR
1 0
MEMORIA M
A MUX1 c9
RAM R
c11 2 L R
c12 ALU 00
0 M
DR 01
c10 N U LOAD
10 MicroPC Memoria
c19 c20 Z X INC
BUS de
FLAGS 1 11 2
Microprograma
c14 c15
c13 PC 2
MicroRI CS Dir. de Salto
c1 c2 c3 c20 2
Figura 4.23: Unidades de Proceso y de Control (Prob. 4)

115
FUNDAMENTOS DE LOS COMPUTADORES
Registros M ALU PC Mem. MAR DR Salto

Comentario Dir. c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 c20 CS Dir. Salto
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Tabla 4.9: Memoria de microprograma (Prob. 4)
116
Instrucción OpCode Tarea a realizar

MOVE A, TMP 0111 TMP = A
MOVE (A), B 1001 B = MEM[A]
BNE A 0011 IF (flag Z = 0) THEN PC = A
MUL (A), B 0100 B = B * MEM[A]
Tabla 4.10: Conjunto de instrucciones (Prob. 4)
5. Sean las secciones de procesamiento y de control de la figura 4.24. La

sección de procesamiento está diseñada para permitir eficientemente la
multiplicación de dos números enteros positivos de 8 bits (A × B, con-
siderando que para que A y B sean positivos deben tener su bit más
significativo a 0).
Inicialmente el multiplicando, A, se almacena en el registro Y , el
multiplicador, B, en el registro X, y el registro AC debe ser puesto a 0.
Durante 8 iteraciones haremos lo siguiente: Si el bit menos significativo
de X está a 1 (X(0) = 1), acumularemos en el registro AC su contenido
más el de Y y desplazaremos un bit a la derecha el par de registros AC −
X. Si, por el contrario, X(0)=0, sencillamente desplazaremos sin sumar
previamente. En el desplazamiento a la derecha, el bit menos significativo
de AC pasará a ser el más significativo del registro X. Después de 8
iteraciones, el resultado de la multiplicación (de 16 bits) queda en el
par de registros AC − X. Un contador de cuatro bits, que puede ser
inicializado a 0 y que puede ser incrementado, nos permite saber cuando
se han producido las 8 iteraciones.
En la tabla 4.11 se describe la función de cada uno de los 9 puntos
de control implicados en este diseño. El formato de cada microinstrucción
no codifica puntos de control en microordenes, sino que asigna un bit del
registro de microinstrucción por cada punto de control. Además añade
un campo de condición de salto, CS, para controlar el Multiplexor-2 y
un campo de dirección de salto. El punto de control c9 permite la carga
del contador de microprograma con la dirección de salto (si vale 0), o con
la dirección que proporciona la ROM de Proyección (si vale 1). Teniendo
en cuenta las siguientes suposiciones:
Los problemas de sincronización y temporales, relativos a los puntos
de control, se consideran resueltos. Si la señal c7 se activa en una
microinstrucción de salto, el incremento del contador se produce
antes que la carga del contador de microprograma.
118
INBUS 8
c1 RI
Y ROM de
c4 Proyeccion
Contador
c7
1 0
MUX1 c9
8 8 8 0 M
FIN U LOAD Memoria
X(0) X INC MicroPC
SUMADOR de
1 2
8 bits Microprograma
c2 c3
2
8 c8
c4
AC X MicroRI CS Dir. de Salto
8 8
8
c5 c6
c1 c2 c3 c4c5 c6 c7 c8c9 2
OUTBUS
Figura 4.24: Unidades de Proceso y de Control del multiplicador

La instrucción máquina MUL, de 0 direcciones, toma los operan-

dos implı́citamente de los registros X e Y y deja el resultado en
los registros AC y X. Evidentemente, deben existir instrucciones
máquina para la carga de los registros X e Y y para la descar-
ga de los registros AC y X, pero consideraremos ese problema de
microprogramación ya resuelto.
El código de operación de la instrucción MUL es 24. En la posición
24 de la ROM de Proyección está almacenada la dirección 100.
Se pide:
Escribir la microrutina asociada a la instrucción MUL y detallar
el contenido binario de la memoria de microprograma, indicando la
dirección inicial de la microrutina según las suposiciones expuestas
anteriormente. Suponer el problema de la búsqueda y decodificación
de la instrucción MUL ya resuelto.
Señal Nemotécnico Significado

c1 loadY Carga en Y el valor de INBUS.
c2 loadAC Carga en AC el resultado del sumador.
c3 loadX Carga en X el valor de INBUS.
c4 clearACyC Pone a cero el registro AC y el Contador.
c5 busAC Saca a OUTBUS el valor de AC.
c6 busX Saca a OUTBUS el valor de X.
c7 IncC Incrementa el Contador.
c8 shift Desplaza a derecha AC y X.
c9 C-Mux1 Control del Multiplexor-1.
Tabla 4.11: Puntos de control del multiplicador (Prob. 5)
6. Sean las secciones de procesamiento y de control microprogramado de la

figura 4.25. Sus elementos más destacados son:
Memoria RAM externa, común para datos e instrucciones, asocia-
da a un registro de datos, DR. En una operación de lectura se
cargará DR con el contenido de la posición de memoria apuntada
por el bus Y . En escritura, el contenido de DR se almacenará en la
posición de memoria indicada por Y .
Un banco de cuatro registros entre los que se encuentra el Contador
de Programa (P C). Las señales de control c1 y c2 seleccionan uno
de los cuatro registros para volcar su contenido al bus X (si c5
está a 1), o para cargarse con el resultado de la ALU (si c6 está a
1). Los puntos de control c3, c4 seleccionan el registro que volcará su

contenido al bus Y (independientemente de c1, c2, c5 y c6).
Acumulador (AC): Puede ser cargado desde el BUS y proporciona
uno de los operandos de la ALU.
Registro de Instrucción (RI): Almacena una instrucción con un
código de operación de 4 bits.
Unidad Aritmético-Lógica capaz de realizar las 4 operaciones bá-
sicas de suma, resta, producto y división. Dispone de dos flags de
estado: Signo (N) y Cero (Z).
Suponer resueltos los posibles problemas de temporización y el si-
guiente tiempo de respuesta para el hardware:
“Volcado de alguno de los registros al BUS”; “Operación ALU del
dato volcado con el que hay en AC” y “Escritura en alguno de
los registros”. Evidentemente, si c5 y c6 se activan en una misma
microinstrucción, el registro que vuelca su contenido al bus X al
comienzo del ciclo, es el mismo que se modifica al final de dicho
ciclo máquina. La carga en el MicroPC se realiza al mismo tiempo
que la escritura en registros, es decir, al final del ciclo de reloj.
DR en la posición de memoria dada por el bus Y .
1 ciclo para cualquier transferencia entre los registros DR, RI, AC
y alguno del Banco de Registros.
El registro de estado también se carga al final del ciclo máquina si
la señal c15 está activa. Sólo las instrucciones aritméticas o lógicas
deben modificar el registro de estado.
Se pide:
a) Diseñar la microrrutina de f etch y decodificación. Descrı́bela en
pseudocódigo y detalla el contenido de la memoria de microprogra-
ma en binario a partir de la dirección 0. Utiliza la tabla adjunta para
detallar las microinstrucciones, utilizando la columna Comentario
para indicar en pseudocódigo el significado de cada microinstruc-
ción.
c) Detallar el número de palabras y el contenido de la ROM de Proyec-
ción teniendo en cuenta el código de operación de cada instrucción

de la tabla 4.12. En total, la Memoria de µPrograma contiene 64
posiciones, aunque en la tabla 4.14 aparezcan menos.

ADD A,B 1111 B ⇐A+B
MOVE A,B 1101 B⇐A
MOVE (A+B),B 1011 B ⇐ M EM [A + B]
BGT C 1001 Si (flag N=0 Y flag Z=0 ) ⇒ P C ⇐ C
Señal Significado
c1, c2 Selección de registro para lectura al bus X y para escritura.
c3, c4 Selección de registro para su volcado al bus Y .
c5 Permiso de salida al bus X del registro seleccionado por
c1, c2.
c6 Permiso de escritura del resultado de la ALU en el registro
seleccionado por c1, c2.
c7 Carga del registro Acumulador (AC).
c8 Carga del registro de Instrucciones (RI).
c9, c10 Escritura y lectura, respectivamente, del registro DR.
c11, c12 Selecciona la operación al realizar en la ALU:
00=Suma. 01=Resta. 10=Producto. 11=División.
c13 Carry de entrada a la ALU.
c14 Vuelca el resultado de la ALU al Bus de Datos.
c15 Actualiza los flags del registro de estado.
c16 Debe estar a 1 cada vez que se utilice la memoria (Chip
Select).
c17 1 = Lectura de memoria a DR. 0 = Escritura en memoria
de DR.
c18 Permite volcar el campo “Dir. de Salto” de la microins-
trucción al Bus de Datos.
c19 Controla el Multiplexor-1.
Tabla 4.13: Puntos de control (Prob. 6)

122
BUS DATOS
c10 c9 c8
c7
c18
DR c5 c14 RI
AC
MEMORIA Y X ROM de
Proyeccion
RAM 2
c1,c2 A
00 1 0
CS RD/WR 2
c3,c4 01 B MUX1 c19
2 L R
c16 c17 c11,c12 c15
10 C c13 ALU 00
0 M
11 PC 01
N U LOAD
10 Memoria
Banco de Registros Z X INC MicroPC
de
FLAGS 1 11 2
Microprograma
c6
2
MicroRI CS Dir. de Salto
c1 c2 c3 c19 2

Banco de Reg. AC, RI, DR ALU SR Mem. Cte M Salto
Comentario Dir. c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 CS Dir. Salto .
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

123
7. La figura 4.26 representa la CPU de un microprocesador con una unidad

de control microprogramada. La descripción de los puntos de control de
la sección de datos se incluye en la tabla 4.16. Como caracterı́sticas más
interesantes de esa sección de datos cabe destacar:
Memoria RAM externa para datos e instrucciones de 64Kx16 bits
(=128Kbytes). La memoria se direcciona directamente desde alguno
de los registros de dirección del banco de registros de dirección. El
dato que se lee de la memoria puede ir a cualquiera de los registros
de cualquier banco, IR, TEMPA o TEMPB. El dato que se escribe en
memoria debe venir de algún registro de uno de los bancos o de la
ALU.
Banco de 4 registros de dirección, de 16 bits cada uno. Este
banco incluye el PC, el registro ı́ndice SI, el registro base B y un
registro temporal de direcciones TMP. c3-c4 son las señales que
controlan la selección del registro de dirección que direcciona la
memoria y que puede volcar su contenido al BUS CPU (si c15=1),
como se indica en la tabla 4.15 (a). El punto de control c5 decide
si se va a leer o a escribir en el registro seleccionado.
c3 c4 Registro de c6 c7 c8 Registro
dirección de datos
0 0 PC 0 0 X Rx
0 1 SI 1 0 X Ry
1 0 B X 1 0 R0
1 1 TMP X 1 1 R1
(a) (b)
Tabla 4.15: (a) Selección del registro de dirección; (b) Selección del registro de
datos
Banco de 16 registros de datos (R0:R15), de 16 bits cada uno.

Están direccionados desde el campo correspondiente de la instruc-
ción máquina, bien Rx o bien Ry, como muestra la tabla 4.17. De
estos registros, el contenido de R0 y R1 viene fijado por el HW
a 0000(16 y 0001(16 respectivamente y no son modificables por el
programador. Las señales que controlan la selección del registro de
datos son c6-c8 según se indica en la tabla 4.15 (b). Como se puede
ver, si c7=0 el campo Rx (si c6=0) o el campo Ry (si c6=1) del Regis-
tro de Instrucción (IR) son los que seleccionan el registro del banco
de registros de datos. Sin embargo, si c7=1, el punto de control c8

seleccionará el registro R0 o R1, independientemente del contenido
de los campos Rx o Ry.
Registro de instrucción (IR) de 16 bits. El formato de instruc-
ción consta de: un campo código de operación C.O. de 4 bits, un
campo no usado, NU, de 4 bits, un campo registro de datos Ry de
4 bits y un campo registro de datos Rx de 4 bits. Las instrucciones
pueden especificar 1 ó 2 operandos explı́citamente. El hecho de que
los registros de datos sean seleccionados desde el IR tiene la ven-
taja de no necesitar microrutinas distintas para instrucciones que
realizan la misma operación sobre registros de datos distintos. Por
ejemplo, la microrutina asociada a la instrucción MOVE R2,R3, es la
misma que la microrutina para MOVE R5,R2 ya que el C.O. de la
instrucción será el mismo y la selección de los registros vendrá es-
pecificada en los campos Rx y Ry de IR.
ALU con sumador/restador asociado a 2 flags de estado, carry
(C) y cero (Z).
En este diseño se suponen resueltos los problemas de temporización
y, dado que la carga de los registros se realiza al final del ciclo máquina,
se requiere 1 ciclo de reloj para:
un acceso de lectura de la memoria y almacenamiento en registro o
lectura de registro y escritura en memoria RAM.
una operación con la ALU y transferencia del resultado a algún re-
gistro.
una transferencia entre registros de bancos diferentes.
una transferencia entre algún registro de uno de los bancos y cual-
quiera de los registros temporales de la ALU (TEMPA, TEMPB).
Además, nos aseguran que la actualización del registro de estado tiene
lugar antes que la carga del contador de microprograma. El registro de
estado sólo se debe modificar en las instrucciones aritméticas o lógicas.
En el problema de diseño se pide:
a) Diseñar la microrrutina de fetch y decodificación. Describirla en
pseudocódigo y detallar el contenido de la memoria de microprogra-
ma en binario a partir de la dirección 0. Utiliza la tabla 4.18 para
detallar las microinstrucciones, utilizando la columna Descripción
para indicar en pseudocódigo el significado de cada microinstruc-
ción.

c) Detallar el número de palabras de la ROM de Proyección y el con-
tenido de las posiciones de esta ROM que conozcas teniendo en
cuenta el C.O. de cada instrucción de la tabla 4.17.
Señal Acción de control

c1 Chip Select de la memoria RAM.
c2 1=Escritura en RAM; 0=Lectura en RAM.
c3, c4 Selección del registro de dirección según la tabla 4.15 (a).
c5 0=Lectura de reg. de dir.; 1=Escritura en reg. de dir. con
el dato del BUS CPU.
c6, c7, c8 Selección del registro de datos según la tabla 4.15 (b).
c9 0=Lectura de reg. de datos; 1=Escritura en reg. de datos
con el dato del BUS CPU.
c10 Carga TEMPA con el dato del BUS CPU.
c11 Carga TEMPB con el dato del BUS CPU.
c12 Carga el registro de estado.
c13 Carga IR con el dato del BUS CPU.
c14 Operación con la ALU: 1=A-B; 0=A+B.
c15 Vuelca al BUS CPU el contenido del registro de dirección
seleccionado.
c16 Vuelca al BUS CPU el contenido del registro de datos selec-
cionado.
c17 Vuelca al BUS CPU el resultado de la ALU.
Tabla 4.16: Puntos de control de la sección de datos (Prob. 7)
Formato de la instrucción
Instrucción Tarea
C.O. NU Ry Rx
MOV Ry,Rx 0011 XXXX Ry Rx Ry → Rx
SUB Ry,Rx 0000 XXXX Ry Rx Rx-Ry → Rx
BCC Ry 0101 XXXX Ry XXXX Si C=0, Ry → PC
MOVE (SI+Ry),Rx 0001 XXXX Ry Rx MEM[SI+Ry] → Rx

c1 c2 c5
Banco de Reg. 16 16
CS R/W Direccion
c3 00 PC c10 TEMPA TEMPB c11
c4 01 SI
MEMORIA
10 B
RAM C 4 A B
11 TMP ALU c14
64K x 16 Z
16 16 bits
DIR
c12
DATOS c17
c15 16
16 16 16 16
BUS_CPU[15:0]
16 c6 16 16
c16 2
4 c1 c2 c18
Rx M 4 2
0000 R0
4 U MicroRI CS Dir. de Salto
0001 R1
Ry X c7
0010 R2 2
c8
. .
IR NU c9 0 00
.. .. Memoria
01 M
. . C INC
de
C.O. U LOAD
MicroPC
Z 10 Microprograma
1111 R15 X
1 11 2
4

Banco de Reg. Datos
c18 MUX1
c13 1 0
ROM de
Proyección
127
Mem. Reg. Dir. Reg. Dat. Carga ALU Transf. M Salto

Descripción Dir.
c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 CS Dir. Salto
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
128
8. Se pretende diseñar la Unidad de Control Microprogramada para el pro-

cesador mostrado en la figura 4.27. La Unidad de Datos contiene los
registros PC e IR, un Banco de registros (B) con 256 registros de 8 bits,
todos ellos accesibles a través de un registro BAR (que se utilizará pa-
ra almacenar el número de registro al que se quiere acceder, bien para
leer su contenido o bien para modificarlo). El registro BDR se utiliza
como registro intermedio para el almacenamiento temporal de los datos
relacionados con alguno de los registros del banco. Esta CPU también
dispone de un registro de estados con 2 flags (Z y N); una ALU con 2
operaciones distintas y 3 registros de propósito general (L y R a su en-
trada, y TMP a su salida); una Memoria (M) de 256 palabras de 8 bits
cada una, que contiene tanto instrucciones como datos y tiene asociado
el registro MAR para las direcciones, no necesitando ningún registro in-
termedio para almacenar temporalmente los datos, sino que son volcados
directamente sobre el BUS principal del sistema, pudiendo almacenarse
dicho valor en cualquier registro directamente conectado con el BUS.
El tamaño de palabra de la ALU, del Banco de Registros (B) y de la
Memoria Principal (M) es de 8 bits.
Es importante resaltar que cada instrucción está almacenada en 1
o varias palabras de memoria, con lo que posiblemente será necesario
realizar más de un acceso a memoria para acceder a la instrucción com-
pleta. El juego de instrucciones de este procesador se caracteriza por
la peculiaridad de que la primera palabra de la instrucción es siempre
el codigo de operación (COP) de la misma, que es por tanto de 8 bits.
El resto de palabras de la instrucción son opcionales (depende de cada
instrucción concreta) y se corresponden a números de registro utilizados
en la ejecución de la instrucción. Estos operandos son tambien de 8 bits
(ver figura 4.27).
El conjunto de instrucciones del procesador junto con sus códigos de
operación y su significado, asi como el número de palabras de memoria de
las que se compone (P) y el orden de acceso se muestra en la tabla 4.19.
Los puntos de control que gobiernan el funcionamiento del data-path se
describen en la tabla 4.20.
Se pide:
a) Diseñar la Unidad de Control de dicho procesador, especificando
claramente el formato de la microinstrucción utilizado y los nuevos
puntos de control si fueran necesarios. Se debe utilizar micropro-
gramación horizontal.
130
W c2
R c3 N
UNIDAD .
B BANCO Z .
8 .
A de de
R FORMATO DE
REGISTROS LAS INSTRUCCIONES
c1 CONTROL
(B) EN LA MEMORIA
PRINCIPAL
8 8 c19
8
BDR PC IR COP
c4 c5 c12 c13 c14 R1 ( opcional )

8 BUS 8
R2 ( opcional )
c15 R3 ( opcional )
c11 c6 c7
L R c18 MAR
8
8 8 W c16 8 bits
N c8 R c17
ALU
Z MEMORIA
c10 c9 PRINCIPAL
TMP (M)
Figura 4.27: Procesador microprogramado (Prob. 8)

Nemotécnico COP Significado P Orden

SALTA Z R1 00001111 si Z=1, PC ← B(R1) 2 (COP, R1)
MUEVE R1,R2 00001010 B(R2) ← B(R1) 3 (COP, R1, R2)
SUMA R1,R2,R3 00000101 B(R3) ← B(R1)+B(R2) 4 (COP, R1, R2, R3)
Tabla 4.19: Conjunto de instrucciones del procesador (Prob. 8)
Señal Nemotécnico Significado

c1 loadBAR Carga en BAR el contenido del BUS
c2 writeB Escritura en el banco de registros (B(BAR) <- BDR)
c3 readB Lectura del banco de registros (BDR <- B(BAR))
c4 vuelcaBDR Vuelca el contenido de BDR en el BUS
c5 loadBDR Carga en BDR el contenido del BUS
c6 loadL Carga en L el contenido del BUS
c7 loadR Carga en R el contenido del BUS
c8 ALU 0: L+R, 1: L+1
c9 loadTMP Carga del registro TMP con el resultado de la ALU
c10 flags Carga el registro de estado del procesador
c11 vuelcaTMP Vuelca el contenido de TMP al BUS
c12 vuelcaPC Vuelca el contenido de PC al BUS
c13 loadPC Carga el PC con el contenido del BUS
c14 loadIR Carga el IR con el contenido del BUS
c15 loadMAR Carga el MAR con el contenido del BUS
c16 writeM Escritura en memoria
c17 readM Lectura de memoria
c18 vuelcaM Vuelca el contenido de la memoria al BUS
c19 incPC Incremento del Contador de Programa
Tabla 4.20: Puntos de control del procesador (Prob. 8)
b) Escribir el microcódigo correspondiente a la rutina común de bús-

queda y decodificación, ası́ como las microrrutinas asociadas a cada
una de las instrucciones máquina mostradas en la tabla 4.19.
c) Si se ha utilizado en el diseño de la Unidad de Control, describir
internamente el Sistema de Proyección.
NOTA: Suponer resueltos todos los posibles problemas de tempo-
rización, y que tanto las operaciones de transferencia entre 2 registros
cualquiera del procesador, cualquier operación con la ALU o acceso a
memoria (lectura/escritura) o al banco de registros (lectura/escritura)
requieren un único ciclo de reloj.
9. Sean las secciones de datos y de control microprogramado de la figura

4.28. Sus elementos más destacados son:
Memoria RAM externa de 232 celdas de 16 bits (4 Giga-palabras),
común para datos e instrucciones. Está asociada a un registro de
datos, DR de 16 bits, y otro de direcciones MAR de 32 bits.
Un banco de ocho registros entre los que se encuentran seis
registros de propósito general, D0-D5 y un registro ı́ndice IX dividido
en 2 partes: IXL, que almacena los 16 bits menos significativos, e
IXH, que almacena los 16 bits más significativos de una dirección de
32 bits. Las señales de control c1, c2 y c3, seleccionan uno de los
ocho registros para volcar su contenido al BUS (si c5 = 1), o para
cargarse con el dato del BUS (si c4 = 1).
Registros temporales (TMP1 y TMP2), que pueden ser cargados
desde el BUS, y proporcionan los operandos de la ALU.
Registro de Instrucción (IR) de 16 bits que almacena una ins-
trucción con un código de operación (OpCode) de 16 bits. Todas las
instrucciones del micro ocupan una palabra en memoria.
Unidad Aritmético-Lógica de 16 bits capaz de realizar 4 ope-
raciones controladas por las señales c9 y c10. Notar que la ALU
proporciona el carry C y que éste a su vez realimenta la entrada de
carry Cin de la ALU.
Notar también que sólo PC y MAR son registros de 32 bits. El resto
de los registros son de 16 bits.
Suponer resueltos los posibles problemas de temporización y, dado
que los registros se cargan al final del ciclo máquina (incluı́do el contador
de microprograma), es necesario:
“Volcado de alguno de los registros TMP1 o TMP2 a la ALU”; “Ope-
ración ALU”, y “Escritura en alguno de los registros”.
1 ciclo para cualquier transferencia entre dos registros cualesquiera
(PC, MAR, D0, IXL, TMP1, ...)
DR en la posición de memoria dada por MAR.
Se pide:
a) Diseñar la Unidad de Control microprogramada. Justificar el ta-
maño del registro de microinstrucción.
b) Diseñar la microrrutina común de búsqueda y decodificación. Utili-
zar la tabla 4.23 para codificar las microinstrucciones. En la colum-
na Descripción detallar en RTL el significado de cada microins-

trucción. Notar que esta tabla no está completa.
c) Diseñar las microrrutinas asociadas a cada una de las instrucciones
de la tabla 4.22.
d) Detallar el número de palabras de la ROM de Proyección y el con-
tenido de las posiciones que conozcas.
SEÑAL Significado
c1, c2, c3 Selección de registro para lectura/escritura al BUS.
c4 Carga del dato del BUS al registro seleccionado por c1,c2, c3.
c5 Volcado del registro seleccionado por c1,c2,c3 al BUS.
c6 Carga del registro TMP1 con el dato del BUS.
c7 Carga del registro TMP2 con el dato del BUS.
c8 Reset del registro TMP2.
c9, c10 Selecciona la operación a realizar en la ALU:
00=L+R, 01=L-R, 10=L+R+1, 11=L+R+C.
c11 Carga del registro de estado.
c12 Vuelca la salida de la ALU al BUS.
c13 Carga los 16 bits menos significativos de MAR con el dato del BUS.
c14 Carga los 16 bits mas significativos de MAR con el dato del BUS.
c15 Carga del registro DR con el dato del BUS.
c16 Vuelca el registro DR en el BUS.
c17 1 = Habilita acceso a RAM; 0 = Deshabilita acceso a RAM.
c18 1 = Lectura de RAM; 0 = Escritura en RAM.
c19 Carga los 16 bits menos significativos de PC con el dato del BUS.
c20 Carga los 16 bits más significativos de PC con el dato del BUS.
c21 Vuelca los 16 bits menos significativos de PC al BUS.
c22 Vuelca los 16 bits más significativos de PC al BUS.
c23 Incrementar PC
c24 Carga del registro IR con el dato del BUS.
Tabla 4.21: Descripción de los puntos de control de la CPU (Prob. 9)

ADD D3,D4 001F(16 D4 ← D3 + D4
BCC IX 0020(16 IF (flag C=1) THEN PC ← IX
MOV D0,D1 0000(16 D1 ← D0
LDIX D5,D2 0003(16 D2 ← MEM[IX+D5]
Tabla 4.22: Subconjunto de instrucciones de la CPU (Prob. 9)

134
PC[31:16] PC[15:0]
PC c23
c20 c19
c22 c21
16 16 16 16 BUS[15:0] 16
16 16 c24
c16 c15 16 16
16 16 c6 c7
IR
DR c14 c13 c5 c4 c12 16 OpCode
16 TMP1 TMP2 c8
MAR
MAR[31:16] MAR[15:0]
32 000 D0 Unidad de Control
MEMORIA
001 D1 c11
2 L R
RAM c9,c10
010 D2 ALU Microprogramada
Cin C
4Gx16 bits
011 D3
100 D4
16
101 D5
c1
CS R/W 110 IXL c1 c2 c3
c2
111 IXH
c17 c18 c3
Banco de Registros
Figura 4.28: Unidades de Datos y de Control (Prob. 9)

Banco Regs. TMP ALU MAR DR MEM PC RI
Descripción Dir.
c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 c20 c21 c22 c23 c24

135
10. Diseñar la unidad de control cableada siguiendo los dos métodos ex-
plicados para el procesador planteado en la sección 4.4 extendiendo el
conjunto de instrucciones con las que aparecen en la tabla 4.24.
Mnemónico Descripción
COMP Complemento del acumulador not(ACC) →
ACC
JMP A Salto incondicional a la posición A: A → P C
SHIFTR Desplazamiento de un bit a la derecha del acu-
mulador: RightShif t(ACC, 1) → ACC
AND A Y lógico del acumulador y el contenido de la po-
sición A: ACC ∧ (A) → ACC
STOREI #N Guarda un valor inmediato en el acumulador:
N → ACC
Tabla 4.24: Extensión del conjunto de instrucciones
11. Para la unidad de control de la figura 4.29 diseñada por el método de

los elementos de retardo,
a) Escribir el diagrama de flujo que implementa y el cronograma de
las señales de control que genera.
b) Representar los elementos de retardo con biestables D con CLEAR
y PRESET indicando la conexión de la señal de reloj y la señal de
inicio (BEGIN).
c) Rediseñar la unidad de control utilizando el método del contador
de secuencias.
C5
C2 C3 C4
C1
1 2 3 4 5
START CARRY
Figura 4.29: Unidad de Control (Prob. 11)
12. La figura 4.31 representa un procesador con control cableado cuyos pun-
tos de control se detallan en la tabla 4.25. Podemos destacar del proce-
sador:
Memoria RAM de 32K palabras de 16 bits. La memoria se estruc-

tura en palabras de dos bytes, y su direccionamiento se realiza a
nivel de byte.
El tamaño de todos los registros existentes es de 1 palabra, ası́ como
el del bus de datos que se ha denotado con busD. Dado el diagrama
propuesto se observa que para almacenar un dato en OP 2 ha de
ser cargado previamente en OP 1. El registro acumulador ACC se
puede usar como registro temporal si fuera necesario.
La ALU permite 4 operaciones: OP 1 + OP 2, OP 1 − OP 2, OP 2 +
0, y OP 2 + 1, generando un bit de estado de cero que puede ser
almacenado en F Z.
Se considera que un solo ciclo de reloj es suficiente para leer o es-
cribir de memoria ası́ como para transferir datos entre registros
conectados. No es necesario considerar en el ejercicio la temporiza-
ción de los puntos de control activos por flanco.
Todas las instrucciones ocupan 2 palabras de memoria. La primera
palabra es el código de operación y la segunda contiene potencial-
mente un operando. Aquellas instrucciones sin operando desapro-
vechan, pues, esta segunda palabra ya que no la usan. Las instruc-
ciones ocupan siempre, un número par de bytes, y por ello PC puede
ser incrementado de 2 en 2 a través de un sumador auxiliar.
..........
8 8
C.OP. word i
Operando word i+1
..........
Figura 4.30: Formato de las instrucciones
Sobre el procesador descrito se pide:

a) Genera el diagrama de estados (flujo) de la unidad de control ca-
bleada, capaz de ejecutar el conjunto de instrucciones reducido que
se muestra en la siguiente tabla. En cada estado ha de indicarse la
operación de transferencia de registro que corresponda, ası́ como los
puntos de control que se activan. Debe considerarse que la búsque-
da y decodificación es común a las instrucciones. Observa que un
decodificador especı́fico Inst-DEC activa una señal correspondiente
a la instrucción fue cargada en IR.
Mnemónico Operando Operación Significado

DUP A A ACC ← 2*A Duplica A y lo guarda en el acumulador
JIZ bdir bdir Si FZ=1 ⇒ Salto al byte bdir, condicionado a FZ.
PC ← bdir
JEQ [bdir] bdir Si OP1=OP2 ⇒ Salto condicional indirecto a la palabra
PC ← Mem(bdir) contenida en bdir cuando OP1=OP2.
JMP Wdir Wdir PC ← 2*Wdir Salto incondicional a la palabra Wdir.
b) Construir la unidad de control cableada, según la metodologı́a de

los elementos de retardo y escribir las ecuaciones de los puntos
de control correspondientes.
’2’
16
+ c6 c7
c11
OP2 a
0 1
c14 MUX1 FZ
ALU
c15 c1 c2 c3 c5 16
PC OP1 b c8
R W OE
16
16 RAM
0 busD(15:0) c4
MUX2
c13 16 16
Dirección Datos
c12
1 c9
c10
MAR 32Kx2bytes IR
c16 ACC
16
Inst-DEC
DUP JMP
JIZ JEQ
UNIDAD DE CONTROL CABLEADA
Figura 4.31: Datapath (Prob. 12)

P.C. Función Ecuación

c1 Habilitación de lectura de RAM c1=
c2 Habilitación de escritura en RAM c2=
c3 Habilita salida de RAM c3=
c4 Carga de OP1: OP1 ← busD c4=
c5 Carga de OP2: OP2 ← OP1 c5=
c6,c7 Operación ALU: 00:a+b, 01:a-b, c6=
10:a+0, 11:a+1 c7=
c8 Abre conexión entre ALU y busD c8=
c9 Carga: ACC ← busD c9=
c10 Volcado de ACC en busD c10=
c11 Carga del bit de estado FZ c11=
c12 Carga: IR ← busD c12=
c13 Carga: MAR ← busD c13=
c14 Selección MUX1 (0:busD, 1:PC+2) c14=
c15 Carga PC con la salida de MUX1 c15=
c16 Selección MUX2 (0:PC, 1:MAR) c16=
Tabla 4.25: Puntos de control (Prob. 12)

5
Sección de
Procesamiento:
Algoritmos Aritméticos
OBJETIVOS
Describir brevemente el HW y los algoritmos encargados de implementar

las operaciones aritméticas en la ALU
Introducir la aritmética en punto flotante a partir de los algoritmos de
aritmética entera
CAPÍTULO 5: SECCIÓN DE PROCESAMIENTO 143
5.1. ARITMÉTICA DE PUNTO FIJO
Vamos a comenzar este tema estudiando la aritmética en punto fijo, de la que

los enteros son el caso particular de estar situado el punto decimal a la derecha
del dı́gito menos significativo del número. Veremos tanto el HW que hay dentro
de la ALU como los algoritmos que se tienen que ejecutar para realizar las
operaciones aritméticas: suma, resta, multiplicación y división. Además
cuando se estudie la aritmética en punto flotante se podrá comprobar como
ésta se basa en operaciones en punto fijo.
5.2. SUMA Y RESTA
Orientaremos esta sección desde dos puntos de vista. El primero será el punto
de vista software, en el que veremos qué algoritmos son necesarios aplicar pa-
ra realizar estas operaciones, en función del convenio de representación de los
operandos (binario natural, Signo/Magnitud, Complemento a 1 o Complemen-
to a 2). Será después cuando veamos las posibles implementaciones hardware
y una comparación entre ellas, atendiendo a las caracterı́sticas, casi siempre
en compromiso, de coste y velocidad.
5.2.1. Algoritmos de suma y resta

Binario natural
Si nos detenemos a pensar en la forma en que se realiza con lápiz y papel la
suma de dos números A y B de n bits, observamos que para la obtención del
dı́gito i-ésimo del resultado, s i , intervienen no sólo los dı́gitos ai y bi de los
sumandos, sino, además, el carry ci , que ha sido generado previamente (en la
etapa i-1). Además, junto con s i , se va a generar el carry ci+1 , necesario para
el cómputo de si+1 :
cn+1 cn ... c3 c2 c1 =C
an . . . a3 a2 a1 = A (5.1)
+ bn . . . b3 b2 b1 = B
sn+1 sn . . . s3 s2 s1 =S
Es decir, el carry ci se genera en la etapa i-1 y se suma en la etapa i.
Suponemos el carry inicial de entrada, c1 , inicializado desde una de las entradas
de control del sumador, de forma que se pueda poner a 0 ó a 1. Como podemos
ver de la suma anterior, sn+1 = cn+1 . Si la aritmética es de n bits, es decir, los

números han de ser representados con n bits, se produce overflow si s i+1 = 1.
Las ecuaciones lógicas necesarias para obtener s i y ci+1 son:
si = (ai ⊕ bi ) ⊕ ci
(5.2)
ci+1 = ai · bi + (ai ⊕ bi ) · ci
La realización de un sumador de 1 bit seguirá la siguiente tabla de verdad

(tabla 5.1), en la que se considera, junto con los dos dı́gitos binarios a sumar,
el acarreo procedente de la etapa anterior, generándose, además del dı́gito de
la suma, el acarreo para la etapa siguiente:
Entradas Salidas
ai bi ci si ci+1
0 0 0 0 0
1 0 0 1 0
0 1 0 1 0
1 1 0 0 1
0 0 1 1 0
1 0 1 0 1
0 1 1 0 1
1 1 1 1 1
Tabla 5.1: Tabla de verdad de la suma
En este apartado hemos tratado la suma de números positivos represen-

tados en binario natural con n bits. Si además queremos realizar operaciones
con números negativos, debemos utilizar los sistemas de representación en
Signo/Magnitud, Complemento a 1 o Complemento a 2.
Signo/Magnitud
Bajo este convenio de representación de enteros negativos, los bits a n y bn de
la expresión 5.1 representan el bit de signo de los sumandos y s n el bit de signo
de la suma. El algoritmo para realizar la suma es:
Si an = bn → Sumandos del mismo signo.
❶ Se suman las magnitudes de n-1 dı́gitos (bits) mediante la ecuación
5.2.
❷ Poner sn = an .
❸ Si cn = 1 ⇒ Overflow.
Si an ̸= bn → Sumandos de distinto signo.

❶ Se restan las magnitudes de n-1 (bits) mediante la ecuación:
si = (ai ⊕ bi ) ⊕ ci
(5.3)
ci+1 = ai · bi + (ai ⊕ bi ) · ci
donde ci es el acarreo de la resta, también llamado borrow .

❷ Si
(
0 ⇒ Poner sn = an ,
cn =
1 ⇒ Poner sn = bn y hacer C2(sn−1 . . . s2 s1 ).
Para restar A − B, habrá que cambiar el bit de signo de B (b n = bn ) y

aplicar el algoritmo de suma comentado anteriormente.
Los inconvenientes de representar los números en S/M son claros:
El algoritmo a seguir es complejo.
El coste asociado al HW necesario es elevado, dado que necesitamos una
unidad sumadora que implemente al ecuación 5.2 y una unidad restadora
que haga lo propio con la ecuación 5.3. Además, es necesario un HW para
hacer el C2 para el caso en que cn = 1.
Complemento a 1
Si los sumandos están representados en un sistema de numeración en C1 de n
bits, el algoritmo de suma es el siguiente:
❶ Sumar los operandos mediante la ecuación 5.2, sin distinguir el bit de
signo del resto de los n bits.
❷ Si cn+1 = 1 se suma 1 al resultado. Es decir, después de operar, se añade
el acarreo de salida.
❸ Si los valores sumados son de igual signo9 hay overflow si el signo del
resultado es distinto del de los operandos. Otra forma de determinar si
hay overflow es mediante la ecuación cn+1 ⊕ cn , que tomará el valor uno
en caso de que éste se produzca.
En este caso, el algoritmo para restar A− B consiste en sumar A+ C1(B).
Este algoritmo tiene la ventaja, frente al de suma/resta en S/M, de no
necesitar un HW especı́fico de resta (no hay que implementar la ecuación 5.3).
Pero aún podrı́a ser más sencillo si nos pudiésemos evitar la suma del acarreo,
necesaria en el algoritmo comentado.
9
Si los sumandos son de distinto signo no puede haber overflow.
Complemento a 2
Si los sumandos están representados en un sistema de numeración en C2 de n
bits, el algoritmo de suma es el siguiente:
❶ Sumar los valores mediante la ecuación 5.2, sin distinguir el bit de signo
del resto de los n bits .
❷ Se desprecia el acarreo de salida (cn+1 ).
❸ Si los operandos son de igual signo, hay overflow si el signo del resultado
es distinto del de los sumandos. Al igual que en el algoritmo para C1,
hay overflow si cn+1 ⊕ cn = 1.
De forma análoga a cuando trabajamos con la representación en C1, para
restar A − B bastará con sumar A + C2(B)
Este algoritmo resulta el más rápido de todos, ya que es sencillo y el acarreo
se desprecia.
Por supuesto, también existen algoritmos de suma/resta para otros siste-
mas de representación de los números, como BCD natural, BCD exceso a 3,
etc, pero se apartan del ámbito de este curso.
5.2.2. Implementación de un sumador

Como se ha visto, cuando usamos los sistemas de numeración binaria en com-
plemento a 1 y complemento a 2, se hace innecesaria la distinción entre adición
y sustracción. La resta se va a poder implementar realizando unas modifica-
ciones mı́nimas sobre el elemento sumador, por lo que en este apartado nos
centraremos en el estudio de los sumadores.
Sumador serie
El sumador elemental (1 bit) que implementa la ecuación 5.2 se puede
realizar en dos etapas. La primera consiste en la construcción de un módulo
llamado half-adder o semi-sumador, como el de la figura 5.1, que implementa
la ecuación:
A HA
S
B A S
S =A⊕B
B C
C =A·B C
Figura 5.1: Semi-sumador
En la siguiente etapa, un sumador completo o full-adder se construye

mediante dos semi-sumadores, como se ve en la figura 5.2, que implementa la

ecuación 5.2 completa.
FA
HA
ci A S si ci si
xi A S B C xi ci+1
yi ci+1
B C yi
HA
Figura 5.2: Sumador completo (de un bit)
Aunque el sumador elemental se emplea normalmente como bloque cons-

tructivo de los sumadores paralelos, que estudiaremos en el siguiente apartado,
es posible construir un sumador utilizando uno sólo de esos elementos suma-
dores. Se tratará de un sumador serie, como el de la figura 5.3, en el que la
suma se irá realizando bit a bit, de un modo secuencial. Para ello, A y B se
pueden almacenar en sendos registros de desplazamiento, debiéndose disponer
además de un biestable en el que almacenaremos el carry generado por cada
etapa (suma elemental) de cara a su utilización en la siguiente.
FA
A an . . . . . . . . . . . . a2 a1 xi si sn . . . . . . . . . . . . s2 s1 S
B bn . . . . . . . . . . . . b2 b1 yi ci+1 FF
ci
CK
Figura 5.3: Sumador serie (de n bits)
Sumadores paralelos
1. Ripple adders (Sumador con acarreo propagado o enlazado)
Supongamos que queremos sumar dos palabras de n bits. En lugar
de pasar todos los bits secuencialmente a través de un simple sumador
elemental, podemos presentar los n bits de los dos operandos en paralelo
a través de n sumadores elementales. Estos n sumadores elementales
están conectados de tal forma que el acarreo de salida del sumador i,
ci+1 , es el acarreo de entrada para el sumador i+1, con 1 ≤ i ≤ n − 1.

Hay una lı́nea de entrada, c1 , y una de salida, cn+1 . Un esquema de un
sumador de este tipo para números enteros de n bits se muestra en la
figura 5.4.
FA c2 FA c3 FA c4 FA cn+1= s n+1
c1 ci ci+1 ci ci+1 ci ci+1 ... cn ci ci+1
a1 xi 1 s a2 xi 2 s a3 xi 3 s an xi n s
i b2 i b3 i ... bn i
b1 yi yi yi yi
s1 s2 s3 s n s n+1
Figura 5.4: Sumador de acarreo propagado (de n bits)
El acarreo puede propagarse desde c1 hasta la última suma en serie,

a través de los n sumadores, de forma que, en el peor de los casos,
el tiempo en realizar una suma corresponde a la suma de los tiempos
empleados por n sumadores elementales. Si se diseña una ALU sı́ncrona,
este tiempo es el que debemos elegir para realizar una suma completa.
2. Carry look-ahead adders (Sumadores con acarreo anticipado)
Si examinamos la ecuación lógica del sumador elemental, podemos
ver que la ecuación del acarreo,
ci+1 = ai · bi + (ai ⊕ bi ) · ci
puede reescribirse en función de dos términos:

a) Generación del acarreo gi+1 = ai · bi
b) Propagación del acarreo pi+1 = ai ⊕ bi
De forma que quedarı́a:
ci+1 = gi+1 + pi+1 · ci
Comenzando con un acarreo inicial c1 y g1 = c1, tenemos la ecuación

de recurrencia: ⎛ ⎞
' i i+1
+
ci+1 = gi+1 + ⎝ pk ⎠ · gj
j=1 k=j+1
donde Σ y Π representan las funciones lógicas OR y AND respectiva-

mente.
Cada uno de los ci se expresa ahora en función de aj , bj y c1 , con
1 ≤ j ≤ i. Esto nos permite diseñar los sumadores con acarreo anticipado
(CLA), en donde un acarreo se genera antes de que su bit suma haya

sido obtenido. Si, por ejemplo, comparamos dos sumadores comerciales
de 4 bits, como el 74LS83 (con arquitectura ripple carry) y el 74LS283
(con arquitectura CLA), encontramos lo siguiente:
Tienen aproximadamente el mismo número de puertas.
El 74LS283 (CLA) tiene, en el peor de los casos, un retardo de 4
niveles de puertas, en lugar de los 8 que le corresponden al 74LS83.
La velocidad del CLA es 3 veces superior a la del 74LS83
Sin embargo, restricciones eléctricas de fan-in y fan-out 10 impiden
una extensión directa del sistema descrito a sumadores para palabras de
gran longitud. La solución es conectar en cascada CLA’s, con el acarreo
de salida de uno conectado al acarreo de entrada del siguiente.
3. Carry save adders (Sumadores con acarreo almacenado)
Supongamos que se necesita sumar m operandos (m > 2). Esto ocu-
rre, por ejemplo, en una multiplicación. La velocidad de esta operación
se puede aumentar dejando la propagación del acarreo para la última
suma.
Comenzaremos por describir como funciona el bloque elemental, pre-
parado para trabajar con tres valores. Estos módulos básicos se podrán
interconectar entre sı́ para ampliar el número de operandos, siguiendo
una estructura que veremos un poco más adelante.
Cuando se va a calcular la suma de tres valores, primero sumamos los
tres números sin propagar el acarreo, que sencillamente “apuntamos” en
una variable, c, mientras guardamos los bits de suma en otra variable s.
A continuación, realizamos s + 2c para conseguir el resultado final. Por
ejemplo, veamos el modo de proceder para sumar x=10, y=5 y z=12,
que podrı́amos dividirlo en dos etapas: cálculo de s y c y obtención del
resultado, s + 2c.
Las ecuaciones necesarias para conseguir s y c son:
si ← xi ⊕ yi ⊕ zi
ci ← xi · yi + (xi ⊕ yi ) · zi
que son prácticamente iguales a las que implementa un full-adder (ecua-
10
Por definición, el máximo número de puertas lógicas que una puerta puede excitar,
permaneciendo los niveles eléctricos en los márgenes garantizados, es el fan-out de dicha
puerta. Por analogı́a, el fan-in de una puerta es una medida de cuánto carga una de las
entradas de dicha puerta a la puerta excitadora. En el circuito que implementa un CLA,
la salida de algunas puertas han de conectarse a las entradas de un gran número de otras
puertas, tanto mayor cuanto mayor sea el número de bits del sumador, pudiéndose alcanzar
lo lı́mites impuestos por el fan-in y fan-out de la tecnologı́a.
ción 5.2), donde 1 ≤ i ≤ n, siendo n el número de dı́gitos de los suman-

dos.
x = 10 001010
y = 5 000101 s 000011
z = 12 + 001100 + 2c 011000
------ ------
s = 000011 011011 => 27
c = 001100
Para implementar un carry save adder (CSA) vamos a usar n suma-

dores completos, pero en vez de conectarlos como en el caso del ripple-
adder, tomamos como entradas los tres sumandos -x, y, z- generándose
las dos salidas, s y c, como se muestra en la figura 5.5 (para el caso n=4).
X Y Z
x4 x3 x2 x1 y4 y3 y2 y1 z4 z3 z2 z1
x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4
CSA FA FA FA FA
s 1 c1 s 2 c2 s 3 c3 s 4 c4
s4 s3 s2 s1 c4 c3 c2 c1
S C
Figura 5.5: Sumador de acarreo almacenado de 4 bits
Es evidente que el tiempo de propagación de un CSA es igual al

tiempo de propagación de los full-adders que lleva dentro, ya que los n
sumadores completos operan en paralelo para obtener s y c.
Utilizando varios CSA’s interconectados, podemos realizar imple-
mentaciones del tipo árbol de Wallace, que nos permiten sumar un núme-
ro grande de operandos, como se puede ver en la figura 5.6.
Es importante notar como el último sumador del árbol de Wallace es
un sumador de acarreo propagado o anticipado de dos sumandos, que a
su salida proporciona la suma total.
a b c d e f g h i
4
CSA 1 CSA 2 CSA 3

2c1 s3
s1 s2 2c2 2c3
CSA 4 CSA 5
2c4
s4 s5
CSA 3
CSA 6 c4 c3 c2 c1
2c5
s6 2c6 0
c4
CSA 7 z4 z3 z2 z1
s7 2c7 CSA 5
SAP
Figura 5.6: Árbol de Wallace para nueve sumandos (a, b, ..., h, i)
5.3. PRODUCTO DE ENTEROS SIN SIGNO O NATURA-

LES
5.3.1. Introducción
Antes de formalizar los algoritmos aritméticos que vamos a implementar, re-
cordaremos como efectuamos la multiplicación con lápiz y papel. Indicaremos
qué recursos hardware serı́an necesarios para su realización como circuito y
expondremos algunas transformaciones simples que reducen la complejidad de
estos procesos.
Consideremos que deseamos obtener el producto Z = Y × X, donde el
multiplicando Y y el multiplicador X admiten la siguiente representación Base
B con n dı́gitos.
X → xn−1 xn−2 . . . x1 x0
Y → yn−1 yn−2 . . . y1 y0
El procedimiento que usamos para multiplicar Y × X en un papel, se
basa en expresar el valor del multiplicador en función de los dı́gitos de su

representación Base B (X es igual a la suma de los dı́gitos de su representación
por las sucesivas potencias de la base), es decir, si tomamos B = 10:
X = xn−1 · 10n−1 + · · · + x1 · 101 + · · · x0 · 100 (5.4)
Al multiplicar Y × X aplicamos la propiedad distributiva en la evaluación
del producto del multiplicando por la nueva expresión del multiplicador (ecua-
ción 5.4). El cómputo se descompone en la suma de n factores, escalados por
las sucesivas potencias de la base. Cada factor es el resultado de multiplicar
un dı́gito del multiplicador por los n dı́gitos del multiplicando.
En la figura 5.7 mostramos un ejemplo de multiplicación de enteros en base
diez siguiendo el algoritmo que utilizamos tı́picamente para multiplicar en un
papel.
Ejemplo: 345 × 123 = 345 × (1 · 102 + 2 · 101 + 3 · 100 ) =
(345 × 1 · 102 ) + (345 × 2 · 101 ) + (345 × 3 · 100 )
345 -> Y 345

x 123 -> X x 123
----- -----
(345x3) 1035 -> PP0
(345x2) 690 -> PP1
+ (345x1) + 345 -> PP2
----------- -------
42435
Figura 5.7: Ejemplo de multiplicación con lápiz y papel
Una implementación hardware del algoritmo del producto, tal y como se

realiza con lápiz y papel, requerirı́a almacenar temporalmente los productos
parciales P Pi . Sin embargo, si, inmediatamente a su obtención, sumamos el
producto P Pi , acumulándolo en una única variable P , obtendremos un sustan-
cial ahorro de recursos de almacenamiento. Para cada dı́gito del multiplicador
obtendremos su producto parcial por el multiplicando y lo acumularemos en
P . La figura 5.8 muestra la realización del mismo producto de la figura 5.7
mediante la acumulación de los productos parciales, junto con el hipotético
HW de multiplicación siguiendo este nuevo algoritmo.
Algorı́tmicamente podemos expresar este procedimiento mediante el si-
guiente pseudocódigo:
Ejemplo: 345×123
Y (n) X (n)
345
x 123 *
-----
SHIFT IZQ
00000 -> P(0)
+ 1035 2n
------
1035 -> P(1) SUMADOR
+ 6900 2n
------
2n
7935 -> P(2)
+ 34500 Z (2n)
------
42435 -> Z
Figura 5.8: Mejora del algoritmo y su implementación
P(0)=0;
for (i=0; i<n; i++)
{
P (i + 1) = xi × Y × B i + P (i);
}
Z = P(n);
donde los ı́ndices entre paréntesis muestran el mismo elemento en distintos

pasos, mientras que los subı́ndices indican componentes de un elemento.
La realización hardware del algoritmo requerirı́a, como puede observarse en
la figura 5.8, un sumador Base B de 2n dı́gitos, un multiplicador Base B para
multiplicar un dı́gito de X por Y y un desplazador a la izquierda de 2n dı́gitos
para implementar los desplazamientos asociados al término B i . Al comienzo
del algoritmo el registro Z debe inicializarse a 0. En la primera iteración, i=0 ,
el desplazador no opera, en la iteración i=1 , realizará un desplazamiento a la
izquierda, para i=2 , dos desplazamientos, etc. También, al final de cada itera-
ción del algoritmo, el contenido del registro X debe desplazarse una posición
a la derecha, ya que el dı́gito menos significativo de X es el que multiplica a
Y.
Sin embargo, el coste HW asociado a este algoritmo puede reducirse signifi-
cativamente. Si se observa el algoritmo, el núcleo del ciclo for está constituido
por la siguiente expresión suma,
P (i + 1) = xi × Y × B i + P (i)
donde se aprecian dos sumados, el valor acumulado hasta ese paso, P (i), y la
aportación del producto parcial, P Pi = xi · Y · B i .
Puesto que el producto parcial P Pi está escalado en B i , la suma no afec-
tará a las componentes i-1, i-2,..., 1, 0 del valor acumulado en P (i). Además,
dados los valores posibles de los dı́gitos y números de n dı́gitos en Base B, se
verificará que xi · Y < B n+1 y, por lo tanto, será un número Base B de n+1
dı́gitos como máximo. Es decir, si el recorrido del ı́ndice se realiza de forma
creciente, las componentes B 2n−1 , B 2n−2 , ..., B n+i+1 del valor acumulado P (i)
serán nulas. Por todo ello, en cada paso de la iteración, sólo n+1 dı́gitos del
valor acumulado P (i) serán susceptibles de cambio. En resumen, bastará con
un sumador Base B de n+1 dı́gitos.
En la figura 5.9 mostramos la realización de la multiplicación anterior
siguiendo el nuevo algoritmo mejorado de un sumador de n+1 dı́gitos.
Ejemplo: 345 × 123
Y AC X Y (n)
345 0000 123

*
+ 1035
→ 1035 123 n+1
0103 512
+ 0690 SUMADOR
n+1
→ 0793 512
n+1
0079 351
+ 0345 AC (n+1) X (n)
→ 0424 351
Z= 0042 435
Figura 5.9: Implementación de la segunda mejora del algoritmo
Este algoritmo consiste en inicializar un registro acumulador, AC, a cero

y luego iterar n veces los dos pasos siguientes:
Sumar con AC el dı́gito menos significativo del registro X por el conte-

nido del registro Y, es decir: AC ← AC + (Y × x 0 ). El dı́gito x0 se ha
marcado en negrita en el ejemplo.
Desplazar el par de registros AC–X una posición a la derecha.
De esta forma, el HW necesario para implementar este algoritmo, también
presentado en la figura 5.9, sólo necesita un sumador de n+1 bits.
5.3.2. Caso Binario. Algoritmo de Suma y Desplazamiento

La particularización del algoritmo del anterior apartado y sus estructuras aso-
ciadas, en el caso binario, traen consigo algunas simplificaciones.
Puede observarse que en el caso binario, el cálculo de x i ·Y se reduce a 00...0
si xi = 0, e Y si xi = 1. Además, el producto de xi · Y es un número de n bits,
lo que permite utilizar un sumador binario de sólo n bits. Deberemos tener
en cuenta que al sumar dos números en binario natural de n bits el resultado
puede ser de n+1. Afortunadamente, en el caso de números binarios natural,
este bit adicional coincide con el acarreo de salida del sumador. Por ello, en
las sumas intermedias, tendremos que considerar este acarreo y salvarlo en
un biestable, F, para introducirlo en el registro AC cuando realicemos el
desplazamiento a la derecha. Todo esto se muestra en la figura 5.10.
Y (n)
CONTROLADOR
SUMADOR
Cout n bits
n
Z (2n)
F AC X (n)
Figura 5.10: Implementación del algoritmo de multiplicación binario
Como vemos, la realimentación del carry de salida, C out , a través del biesta-
ble, está pintado con lı́nea discontinua. Esa realimentación puede ser suprimida
en el caso de que los números a multiplicar sean positivos y estén representados
en signo/magnitud, C1 ó C2, ya que en ese caso serán de la forma 0XXXX...XX,
y en las sumas implicadas en el algoritmo nunca se producirá carry de salida.
Para terminar, mostramos como queda el algoritmo de multiplicación que
debe implementar el Controlador de la figura 5.10:
AC=0;
for (i=0; i<n; i++)
{
if (x(0)==1) SUMA Y;
DESPLAZA;
}
Este algoritmo implementado en el controlador, ya sea mediante control ca-

bleado o microprogramado, será el encargado de generar las señales de control
apropiadas para que se realicen las sumas y los desplazamientos necesarios, en
función del contenido del registro X, cuyo bit menos significativo es testeado
desde el controlador.
5.3.3. Mejora para saltar sobre ceros y unos consecutivos (bit-

scanning)
En la formulación del algoritmo de multiplicación del apartado anterior, la

aparición de 0’s en el multiplicador hace que no se realice la suma y sólo se
efectué el desplazamiento (saltar sobre 0’s). A continuación vamos a demostrar
como con un sumador-restador se pueden efectuar tanto saltos sobre cadenas
de “0” como de “1” consecutivos. Sea un número binario con una cadena de
k unos consecutivos a partir de la posición i.
<- k ->
j i
...011......1110....
El valor con que contribuye dicha cadena de 1’s al número representado será:
. . . + 2i+k−1 + 2i+k−2 + ... + 2i+1 + 2i + · · · =

= . . . + (2k−1 + 2k−2 + .. + 21 + 20 ) · 2i + · · · =
= . . . + (2k − 1) · 2i + · · · =
= . . . + 2i+k − 2i + . . .
Por lo tanto, la contribución de las k sumas puede sustituirse por una suma
y una resta. De esta forma, podemos reescribir el algoritmo de multiplicación
binaria, ya que si Y es el multiplicando y el multiplicador, X, contiene en su
representación una cadena de unos de longitud k a partir del bit i-ésimo, la
ecuación parcial resultante de desarrollar X × Y queda:
Y · (2i+k−1 + 2i+k−2 + ... + 2i+1 + 2i ) = Y · 2i+k − Y · 2i
Es decir, el efecto de una cadena de 1’s consecutivos en el multiplicador puede

sustituirse por restar el multiplicando en la posición en que comienza la cadena
y sumar el multiplicando en la posición posterior al último uno de la cadena.
Los desplazamientos, en cada paso, se siguen manteniendo.
En pocas palabras, sólo habrá suma o resta del multiplicando al valor
acumulado cuando en el recorrido de los dı́gitos del multiplicador se produce
un cambio con respecto al dı́gito anterior.
Esta idea puede ser plasmada en el código del algoritmo de dos formas
distintas:
(a) Con ayuda de un flag que informe si estamos o no en una cadena de 1’s.
(b) Analizando conjuntamente el dı́gito del multiplicador correspondiente a
la etapa actual y el anterior.
En la opción (b), en lugar de un flag se utiliza el bit anterior del multiplicador
(al comienzo x−1 = 0). La decisión sobre si hay que sumar o restar el multi-
plicando se efectúa según la tabla 5.2, analizando en cada paso de la iteración
i el bit i-ésimo del multiplicador y el anterior, x i−1 .
Dado que se realizan sumas y restas, los resultados parciales pueden ser
negativos, por lo que habrán de ser almacenarlos considerando su signo. Si
en la implementación hardware se utiliza únicamente un sumador binario y la
resta se realiza mediante la suma del complemento a dos del substraendo, los
resultados negativos saldrán en C2. Para respetar el signo de los resultados
parciales, los desplazamientos deberán ser aritméticos (extensión de signo).
Como siempre, el resultado de sumar o restar dos números de n bits puede
requerir n+1 bits, pero en este caso (suma/resta en C2) el bit adicional no
xi xi−1 Operación
0 0 desplazar (cadena de 0’s)
0 1 sumar Y y desplazar (fin cadena de 1’s)
1 0 restar Y y desplazar (comienzo cadena de 1’s)
1 1 desplazar (cadena de 1’s)
Tabla 5.2: Operación a realizar en el algoritmo bit-scanning según los bits del
multiplicador, X
coincidirá con el carry, por lo que habrá que utilizar un sumador de n+1
dı́gitos. El algoritmo quedarı́a:
AC=0; X(-1)=0
for (i=0; i<n; i++)
{
if (x(i)==0 AND x(i-1)==1) SUMA Y;
if (x(i)==1 AND x(i-1)==0) RESTA Y; /*+C2(Y)*/
DESPLAZA;
}
/* Corrección */
if (UltimaOperacion==RESTA) SUMA Y;
donde la última lı́nea del código tiene en cuenta el caso en que el multipli-
cador (en binario natural) tenga su bit más significativo a uno, con lo cual la
última operación serı́a una resta y el resultado serı́a incorrecto. Eso se corrige
sumando Y después de la última iteración si la última operación fue una resta.
Por último, presentamos un ejemplo de ejecución de dicho algoritmo y el
HW necesario para su implementación en la figura 5.11
En general, el número de sumas/restas efectuadas en este algoritmo será me-
nor que el de sumas en el clásico basado en suma y desplazamiento. Sin em-
bargo, la eficiencia depende de los datos y, en el peor caso (secuencia de unos
y ceros alternados, ...010101...), requiere más operaciones y, por lo tanto, más
tiempo de cómputo que el tradicional de suma y desplazamiento.
5.3.4. Recodificación del Multiplicador

Un modo de reducir el número de iteraciones del algoritmo de suma y desplaza-
miento es recodificando el multiplicador como un número Base 2c, agrupándolo
Ejemplo: 0011 × 0111 ⇒ (3 × 7)

0 Y (n)
n+1
Y AC X
0011 00000 0111
+C2(Y) 11101
→ 11101 0111 n+1
→ 11110 1011
SUMADOR Cin
→ 11111 0101 n+1 bits
CONTROLADOR
11111 1010
n+1
+(Y) 00011 Z (2n+1)
→ 00010 1010 AC X (n)

X-1
00001 0101
Figura 5.11: Implementación del algoritmo bit-scanning
según bloques de c-bits. Habrá que disponer de 2c-1 múltiplos del multipli-
cando. El número de iteraciones se reducirá a nc . En cada paso se analizarán
c-bits y se acumulará el múltiplo correspondiente. Los desplazamientos serán
de c-bits. En la tabla adjunta mostramos los múltiplos para el caso c=2.
xi+1 xi Operación
0 0 desplazar dos bits
0 1 sumar Y y desplazar dos bits
1 0 sumar 2Y y desplazar dos bits
1 1 sumar 3Y y desplazar dos bits
Tabla 5.3: Recodificación de los bits del multiplicador (para c = 2)
Por ejemplo, si Y=3 y X=30, el multiplicador puede expresarse como:
X = 01 11 10 = (01)24 + (11)22 + (10)20
de forma que:
. /
Y × X = Y × (01)24 + (11)22 + (10)20 = Y · 24 + 3Y · 22 + 2Y · 20
Este método, a su vez, puede combinarse con el de salto sobre ceros y

unos. En el caso de c = 2, esto nos ahorra el cálculo de 3 · X, que es el de
mayor complejidad, ya que implica un desplazamiento y una suma. En el caso
en que c = 1, el algoritmo se llama de Booth cuando los operandos están
representados en C2. El algoritmo es exactamente igual al del bit-scanning

de la página 158 quitando la última lı́nea (la corrección final). Por tanto, el
algoritmo de Booth permite multiplicar números en C2 (ya sean positivos o
negativos). Al igual que le ocurrı́a al algoritmo bit-scanning, un uno (o un
cero) aislado provoca una resta y una suma, cuando el algoritmo de suma
y desplazamiento sólo da lugar a una suma. De esta forma, el algoritmo de
Booth genera, en el caso de un multiplicador con unos y ceros alternados, n/2
sumas y n/2 restas, frente a las n/2 sumas que generarı́a el algoritmo de suma
y desplazamiento. Sin embargo, ese inconveniente se resuelve mediante una
optimización del algoritmo de Booth: el algoritmo de Booth modificado, que
detecta unos y ceros aislados, por lo que es uno de los más usados.
5.4. DIVISIÓN DE ENTEROS SIN SIGNO
En nuestro estudio de la división sólo nos detendremos en el caso de que los

operandos sean enteros sin signo. Muchas máquinas realizan una conversión,
desde la representación en C2 o C1, de los operandos involucrados en la divi-
sión, a su representación en signo magnitud. De esta forma, la división puede
realizarse conforme a los algoritmos que se exponen en este apartado, tratando
el signo aparte.
5.4.1. División Con Restauración

Cuando realizamos la división entera Y ÷ X, siendo Y el dividendo y X el
divisor, buscamos el cociente Q y el resto R. Cuando dividimos dos números
en un papel, por ejemplo 13 entre 5, determinamos que el cociente “cabe”
a 2 y que el resto es 3 (ya que 13 − (2 · 5) = 3). La elección que hacemos
del cociente, en este caso 2, es fruto de una aproximación que hacemos más
o menos mecánicamente, pero que lleva implı́cita la condición matemática de
que el resto (residuo) tiene que ser positivo y menor que el divisor.
Esa aproximación al dı́gito del cociente apropiado, que nosotros elegimos
rápidamente, algorı́tmicamente sólo se puede implementar mediante el méto-
do de ensayo y error. Por ejemplo, en el ejemplo anterior, un algoritmo irı́a
probando cocientes desde el 9, 8, ..., hasta llegar al 2. Es decir, primero pro-
barı́a el cociente 9, restarı́a 45 y al resultar un resto negativo (-32), rectificarı́a
volviendo a sumar 45 y cambiando el cociente a 8. Este cociente también da
lugar a un resto negativo, ası́ que bajarı́amos a 7 y ası́ sucesivamente hasta
llegar al cociente 2, que es el primero que da un cociente positivo y menor que
el divisor, X.
En el caso binario podemos hacer un análisis parecido, con la simplificación

de que las únicas posibilidades de los bits del cociente son 0 y 1. Es decir, se
empieza “apostando” por que el bit del cociente será uno, es decir, restando el
divisor. En caso de que el resto sea positivo, hicimos una buena apuesta, pero
en caso contrario, hay que restaurar y cambiar el cociente a 0. En la figura
5.12 vemos un ejemplo de aplicación de este algoritmo.
Ejemplo: 15 ÷ 2 ⇒ (1111 ÷ 0010)
X AC Y
0010 0 0 0 1 1 1 1
+C2(X) 1 1 1 0 Resta
1 1 1 1
+X 0 0 1 0 Restaura
← 0 0 0 1 1 1 1 ←0
0 0 1 1 1 1 0
+C2(X) 1 1 1 0 Resta
← 0 0 0 1 1 1 0 ←1
0 0 1 1 1 0 1
+C2(X) 1 1 1 0 Resta
← 0 0 0 1 1 0 1 ←1
0 0 1 1 0 1 1
+C2(X) 1 1 1 0 Resta
← 0 0 0 1 0 1 1 ←1
0 0 1 0 1 1 1
R= 001 Q=0111
Figura 5.12: Ejemplo del algoritmo de división con restauración
El circuito más simple que implemente la división binaria deberá ir ajus-

tando metódicamente la posición del divisor en relación con el dividendo y
realizar una sustracción. Si el residuo es cero o positivo, se determina el bit
del cociente como 1, el residuo se amplı́a con otro bit del dividendo, el divisor
se vuelve a ajustar y se efectúa otra sustracción. Por otra parte, si el residuo
es negativo, se determina el bit del cociente como 0, el dividendo se restaura
sumándole de nuevo el divisor y este divisor se ajusta para otra sustracción.
El algoritmo quedarı́a entonces como el de la figura 5.13
En la figura 5.14 se muestra un circuito con el que se podrı́a implementar la
AC=0;
for (i=0; i<n; i++)
{
RESTA X;
if (AC(n-1)==1)
{
RESTAURA (SUMA X);
DESPLAZA con 0;
}
else DESPLAZA con 1;
}
Figura 5.13: Algoritmo de división con restauración
técnica anteriormente expuesta de división con restauración. En él, un divisor

positivo de n bits se carga en el Registro X y un dividendo positivo de n bits
se carga en el Registro Y, al principio de la operación. El Registro AC,
de n-1 bits, se pone a 0. Cuando la división se termine, el cociente de n bits
estará en el Registro Y y el residuo en el AC. Las substracciones necesarias
se facilitarán si usamos aritmética en Complemento a 2.
5.5. ALGORITMOS EN PUNTO FLOTANTE
La aritmética con números en punto flotante, expresados mediante una man-

tisa y un exponente, se traduce en un algoritmo que termina realizando
operaciones enteras con la mantisa y el exponente. Estos algoritmos pueden
ser emulados por SW, repercutiendo en un incremento del coste, o se pue-
den implementar mediante HW. En particular, los coprocesadores aritméticos
contienen una gran cantidad de HW dedicada a realizar estos algoritmos para
números en punto flotante, permitiendo liberar a la CPU del computador de
esa complicada tarea.
5.5.1. Suma y Resta

Dados dos números en punto flotante, X = M 1 · B E1 e Y = M2 · B E2 , su suma
se realiza en cuatro pasos (la resta es análoga):
❶ Detectar el operando de mayor exponente.
X (n)
n n
Control
SUM/RES
n bits
1
n-1
AC (n-1) Y (n)
n-1 1
Figura 5.14: Implementación del algoritmo de división binario
❷ Desplazar la mantisa del operando de menor exponente |E 1 − E2 | · log 2 B

posiciones. La base B debe ser una potencia de 2 (B=2 en IE 3 –754,
B=16 en el IBM-360), para aplicar esta fórmula.
❸ Sumar las mantisas (o restarlas en caso de que tengan distinto bit de
signo).
❹ Normalizar.
5.5.2. Multiplicación
Dados X = M1 · B E1 e Y = M2 · B E2 , su producto P viene dado por:
P = M1 · M2 · B E1 +E2
El algoritmo para X e Y normalizados es:
❶ Sumar los dos exponentes, realizando los ajustes necesarios para obtener
la notación en exceso correcta.
❷ Multiplicar las mantisas.
❸ Normalizar la mantisa resultante.
Debemos tener en cuenta que si las mantisas ocupan n bits, el producto
resultante será de 2n bits, por tanto, debemos descartar los n bits menos
significativos.
5.5.3. División
Dados X = M1 · B E1 e Y = M2 · B E2 , su cociente Q viene dado por:
Q = M1 /M2 · B E1 −E2
El algoritmo para X e Y normalizados es:
❶ Restar los dos exponentes, realizando los ajustes necesarios para obtener
la notación en exceso correcta.
❷ Dividir las mantisas, guardando sólo el cociente.
❸ Normalizar la mantisa resultante.
Si E1 y E2 están representados en exceso, el exponente resultante vendrá da-
do por su diferencia sumándole el exceso. Hay que preguntar si el divisor es
cero, para evitar que se produzca una división por cero. Se puede realizar la
resta de los exponentes en paralelo con la división de las mantisas.
Si en lugar de utilizar un algoritmo de división (con o sin restauración)
se quiere usar un multiplicador en punto flotante, se puede seguir el llamado
método de la división convergente.
SINOPSIS
Ya se dijo con anterioridad que las instrucciones más frecuentes en los progra-
mas son las que deben ser implementadas con más “esmero” para que consu-
man pocos ciclos de reloj. Pues bien, las instrucciones aritméticas pertenecen
a ese tipo de instrucciones que aparecen frecuentemente. Por tanto, no nos
debe sorprender que se investigue intensamente en ese campo con la intención
de encontrar cada vez mejores técnicas para implementarlas. En este tema
sólo hemos introducido algunos principios, pero nos dan una idea de cómo
está construido, más o menos, una unidad aritmético lógica o un coprocesador
aritmético para números en punto flotante.
1. Realizar las siguientes sumas con números de 6 bits: 12+9, 27-15, 14-19,
-7-13, 23+10, -20-13; representando los números mediante los siguientes
convenios:
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
2. Haz, con números de 8 bits trabajando en
a) Complemento a 1
b) Complemento a 2
las operaciones siguientes:
00101101 + 01101111
11111111 + 11111111
00000000 − 11111111
11110111 − 11110111
3. Encuentra la razón por la que, en el algoritmo de suma/resta en C1, hay
que sumar el carry de salida al resultado.
4. Los números decimales con signo de n − 1 dı́gitos se pueden representar
mediante n dı́gitos sin signo utilizando la representación en complemento
a 9. El complemento a 9 es el complemento a la base menos 1 cuando
la base es 10 (igual que el C1 es el complemento a la base menos uno
cuando la base es 2). El C9 de un número decimal N se obtiene mediante
la siguiente expresión:
C9(N ) = 10n − 1 − N
donde n es el número de dı́gitos con que trabajo. Una técnica para hacer
el C9 de un número consiste en restar cada dı́gito de 9. Ası́, el negativo
de 014725 es 985274. Se pide:
a) Expresa como números de tres dı́gitos en complemento a 9 los si-
guientes números: 6, -2, 99, -12, -1, 0.
b) Determinar la regla por la cual se suman los números en comple-
mento a 9.
c) Realizar las siguientes sumas con dicha técnica:
1) 0001 + 9999
2) 0001 + 9998
3) 9997 + 9996
4) 9241 + 0802
5. Los números en complemento a 10 son análogos a los números en com-

plemento a 2. Un número negativo en C10 se forma con sólo sumar 1 al
número correspondiente en C9, prescindiendo del acarreo. Más formal-
mente, el C10 de un número decimal N se obtiene mediante la siguiente
expresión:
C10(N ) = 10n − N
¿Cuál será la regla para la adición en complemento a 10?
6. Cuando realizamos operaciones de suma/resta en decimal, realmente es-
tamos utilizando un algoritmo de suma/resta para números decimales
representados en signo/magnitud, donde el “dı́gito” de signo esta repre-
sentado por el + o el − que antecede al número. Realiza, con aritmética
decimal de tres dı́gitos más el signo, las siguientes sumas y comprueba
que el algoritmo que debes utilizar es semejante al visto en teorı́a para los
números en binario: (−264)+(−858), (+858)+(−264), (+264)+(−858).
7. Árbol de Wallace
a) Dibujar el árbol de Wallace para sumar 6 números enteros mediante
CSA’s (Carry Save Adders). ¿Cómo ha de ser el último sumador?
b) Sumar 12 + 5 + 7 + 3 + 10 + 9 siguiendo la estructura previa.
8. ¿Cuándo tiene sentido utilizar sumadores con acarreo almacenado (CSA)?
Construir el Árbol de Wallace para sumar 7 − 5 + 9 y realizar la suma
utilizando aritmética de 6 bits en C2.
9. Realiza las siguientes multiplicaciones mediante el algoritmo de multi-
plicación binario de suma y desplazamiento con n=5.
a) 12 × 10
b) 7 × 12
c) 6 × 15
10. Realiza las siguientes divisiones mediante el algoritmo de división binario
con restauración con n=5.
a) 12 ÷ 3
b) 15 ÷ 2
11. Realiza las siguientes operaciones con números en punto flotante en el
formato IEEE 754.
a) C30C0000 + C1500000
b) 3B370000 + 39F 68000
6
Memorias
OBJETIVOS
Entender los principios de localidad y jerarquı́a de memoria

Introducir las técnicas de memoria entrelazada, asociativa y caché
CAPÍTULO 6: MEMORIAS 169
6.1. ANCHO DE BANDA, LOCALIDAD Y JERARQUı́A DE

MEMORIA
La Memoria contiene la mayor parte de las instrucciones y datos del programa

que se está ejecutando. Lo que no cabe se almacenará en memoria secundaria,
por lo que, si consideramos ésta como parte de la memoria, podemos afirmar
que toda la información de nuestros programas se encuentra en memoria.
Las dos caracterı́sticas más importantes de la memoria son el tamaño y el
ancho de banda. El tamaño es su capacidad, es decir, el número de palabras
que puede almacenar. El ancho de banda es el número de palabras que
podemos acceder por unidad de tiempo, determinando por tanto la velocidad
a la que podemos trabajar con ella.
La disparidad entre la velocidad a la que son capaces de computar hoy dı́a
los procesadores y el ancho de banda de las memorias plantea un importante
problema. Esto es debido a que el micro procesa mucho más rápido que la
velocidad a la que las memorias son capaces de suministrarle los datos. La
situación ideal se alcanzarı́a si Velocidad del Procesador = Velocidad de la
Memoria.
Para paliar este problema se alcanza un compromiso. Se invierte un dinero
en tecnologı́a de alta velocidad para aumentar el ancho de banda de la memo-
ria. Lo ideal serı́a construir una memoria suficientemente grande y con gran
ancho de banda, pero la tecnologı́a es tan cara que resulta prohibitivo, por lo
que sólo se usará cuando el gasto adicional que supone justifique la inversión.
Tendremos, por lo tanto, un compromiso entre tamaño y ancho de banda, de
modo que si aumentamos uno se debe reducir otro si queremos mantener un
precio constante.
La solución que se adopta, siguiendo siempre criterios económicos y de
factibilidad, es usar diferentes configuraciones de memoria más rápidas (y pe-
queñas) donde podamos sacar alguna ventaja por la inversión adicional que
suponen. Las estrategias más usadas son:
Entrelazamiento de memoria
Empleo de memorias asociativas (se usan con memorias caché y virtual)
Memoria caché
Memoria virtual
La efectividad de estas soluciones se basan en el principio de localidad, que
puede ser formulado según dos vertientes:
a) Localidad Temporal: Si estamos referenciando la posición de memoria
I, es muy probable que la volvamos a referenciar en un breve periodo
de tiempo, es decir, que la información que utilizo en un momento dado

la volveré a utilizar pronto. Se puede ver claramente que esto es lo que
sucede en los lazos.
b) Localidad Espacial: Si la posición de memoria I es referenciada, es muy
probable que a continuación se referencien direcciones cercanas a I o
contiguas en memoria. Esto es lo que ocurre cuando accedemos a datos
relacionados como arrays, matrices. Se debe a que los programas, en su
mayor parte, son secuenciales.
El principio de localidad puede resumirse en lo que se denomina la Regla
90/10, que nos dice que el 90 % del tiempo de ejecución de un programa se
consume en el 10 % del código. Si estos dos principios no se cumpliesen, no
tendrı́a sentido aplicar las técnicas de memoria que vamos a estudiar en este
tema.
Jerarquı́a de Memoria
La aplicación de las técnicas de memoria caché, virtual, entrelazada... se lleva
a cabo implementando una jerarquı́a de memoria de la siguiente forma:
Costosas
Registros CPU
Rápidas
Caché
Memoria Principal
Entrelazada
Más Capacidad
Económicas Memoria Secundaria
Lentas
Figura 6.1: Jerarquı́a de Memorias
En la parte más alta de la pirámide se sitúan las memorias más rápidas,

que al ser también las más costosas serán las de menor tamaño. En el otro
extremo, tendremos las memorias de más capacidad, que además serán las más
lentas y económicas.
6.2. ORGANIZACIÓN DE LA MEMORIA
6.2.1. Memoria Entrelazada

Esta técnica consiste en dividir la memoria en módulos a los que podemos ac-
ceder de manera independiente, de modo que, en un mismo instante, es posible
trabajar con todos los módulos a la vez. De este modo podemos multiplicar
el ancho de banda (en el mejor de los casos) por el número de módulos que
estemos utilizando.
Vamos a suponer que tenemos una memoria de N = 2 n palabras y que
ésta se encuentra repartida en M = 2m módulos. Hay dos posibles esquemas,
cada uno con sus ventajas e inconvenientes:
a) Orden Superior: Palabras consecutivas van a parar al mismo módulo.
m bits n-m bits
Módulo Dirección dentro del Módulo
DIR DIR DIR DIR

Decodificador ...
M-1 M-2 1 0 0 1 M-2 M-1
... CE CE CE CE
...
Figura 6.2: Memoria Entrelazada de Orden Superior
b) Orden Inferior: Palabras consecutivas van a parar a módulos consecuti-

vos.
n-m bits m bits
Dirección dentro del Módulo Módulo
DIR DIR DIR DIR

... Decodificador
0 1 M-2 M-1 M-1 M-2 1 0
CE CE CE CE ...
...
Figura 6.3: Memoria Entrelazada de Orden Inferior
El rendimiento de este tipo de memorias se degrada cuando tenemos con-

flictos de memoria. Un conflicto de memoria se produce cuando dos accesos

consecutivos se refieren al mismo módulo. En el peor de los casos, cuando
siempre direccionamos al mismo módulo, no tendremos ninguna ganancia con
respecto a una memoria convencional (un solo módulo). Sin embargo, en el
mejor de los casos, si conseguimos que M direcciones consecutivas se refieran
a cada uno de los M módulos, lograremos multiplicar la velocidad del módulo
por M .
Si observamos el funcionamiento de cada una de las posibles configuracio-
nes, veremos como se darán más conflictos en la de orden superior, fenómeno
explicado por el principio de localidad espacial.
Sin embargo, las memorias entrelazadas de orden superior tienen una serie
de ventajas:
Se usan en sistemas multiprocesador, en los que cada procesador accede
a su propio módulo.
Se expande con facilidad. Ampliar su tamaño será poco más complejo
que añadir nuevos módulos.
Si se rompe un módulo, solo afectará a un área de memoria localizada.
De cualquier modo, normalmente se usa la técnica de entrelazamiento de
orden inferior, ya que es la que minimiza el número de conflictos.
Rendimiento de Memorias Entrelazadas
En este apartado se analizará el rendimiento de un sistema de memoria en-

trelazada de orden inferior, considerando M el factor de entrelazamiento. Su-
pondremos que el factor limitante es la operación de memoria, despreciando el
tiempo de carga de los latches. El cálculo del rendimiento se realiza para una
traza equiespaciada con distancia entre las peticiones Q, es decir, la solicitud
de peticiones es {0, Q, 2Q, 3Q, ...}.
Para el caso de entrelazamiento con latches a la salida, tendremos que,
si Q ≥ M , es imposible leer en paralelo más de una petición, ya que
la distancia entre ellas es mayor que el rango de posiciones guardada
simultáneamente en los latches. Si por el contrario Q < M , podemos
obtener más de una petición en paralelo con una sóla lectura simultánea
de los módulos. En esta situación, si Q = 1, tendremos el máximo pa-
ralelismo, ya que accedemos a todo el rango de posiciones presentes en
los latches tras el acceso a los módulos de memoria. Si 1 < Q < M , es
la relación M/Q la que limita el número de accesos disponibles en los
latches tras el acceso a los módulos. La siguiente expresión proporciona
la aceleración (α) del sistema bajo las restricciones mencionadas 11 :
(
1 si Q ≥ M
α= 0 M
1
Q si 1 ≤ Q < M
En el caso de entrelazamiento con latches a la entrada, la limitación en

el paralelismo de acceso a los módulos viene dado por las colisiones de
acceso a un módulo. Como la traza que analizamos está constituida por
peticiones de la forma kQ, con k ∈ N, existirá colisión (acceso al mismo
módulo) entre dos peticiones kA Q, kB Q si su diferencia es múltiplo de M
(ya que dichas peticiones se hayarán mapeadas en el mismo módulo). Por
tanto, la aceleración del sistema será aquél valor natural, más pequeño,
que multiplicado por Q proporciona un múltiplo de M , es decir:
• m.c.m.(Q, M ) M
α = min{k ∈ N | k · Q = M } = =
Q m.c.d.(Q, M )
6.2.2. Memoria Asociativa

Consideremos la siguiente tabla, una estructura bastante usada para organizar
la información:
APELLIDO PESO TALLA EDAD
PÉREZ 63 1.71 27
GARCÍA 90 1.87 45
LÓPEZ 82 1.83 33
MARTÍN 51 1.64 61
MILLER 100 2.05 24
ANSLEY 110 2.04 25
La información en la tabla está formada por una serie de entradas llamadas
registros (uno por cada lı́nea), y estos a su vez se dividen en campos (en el
ejemplo son peso, talla y edad).
A la hora de acceder (leer o escribir) a la tabla tenemos varias posibilidades.
a) La más común es la que proporcionan las memorias con acceso aleatorio,
es decir, especificando la dirección fı́sica del dato que queremos acceder.
La dirección fı́sica no tiene ninguna relación lógica con la información
11
Con ⌈x⌉ indicamos el ceil de un número, es decir el entero más cercano hacia +∞, por
ejemplo ⌈3.5⌉ = 4, y ⌈−3.5⌉ = −3. El entero más cercano hacia −∞ se denota ⌊x⌋ y se
conoce como función floor.
que almacena, por lo que este método introduce cierta complejidad lógica
al ser un método de acceso artificial.
b) Emplear uno (o varios) campo(s) para direccionar la información que
queremos localizar. Por ejemplo, nos podrı́a interesar conocer los datos
correspondientes a la persona cuyo campo T ALLA = 1.83. En este tipo
de memoria usarı́amos el campo T ALLA para direccionar y ésta nos
devolverı́a el registro completo: L ÓPEZ, 82, 1.83, 33.
Esto también se podrı́a conseguir con una memoria normal, pero para ello
habrı́a que recorrer toda la tabla secuencialmente en busca de las posibles
concordancias del campo deseado. Al tener que acceder secuencialmente a
todas las posiciones de memoria, este método serı́a muy lento. La ventaja de
las memorias asociativas es que las búsquedas de todas las entradas se realiza
simultáneamente.
Podemos definir la memoria asociativa como aquella que tiene capacidad
de acceder a una palabra almacenada usando como dirección un subcampo
de dicha palabra. La búsqueda de ésta la realiza en paralelo. Este tipo de
memorias recibe otros nombres: MDC o memoria Direccionable por Contenido
(CAM en inglés); memoria de búsqueda en paralelo o memoria multiacceso.
Se usa en gran variedad de aplicaciones, como:
Gestión de memoria caché.
Gestión de memoria virtual.
Manipulación de información almacenada en bases de datos.
Tratamiento de señales de rádar, imágenes.
Inteligencia artificial, etc.
El hecho de que se utilice solo en aplicaciones muy concretas es debido a
que tienen un elevado coste, pues implica redundancia del hardware. Su coste
es bastante superior a una memoria RAM convencional.
La estructura del hardware que implementa este tipo de memorias aparece
representada en la figura 6.4.
Las Celdas Ci son capaces de almacenar un registro completo (apellido,
peso, talla, etc,...). La gestión de los accesos los realiza la Unidad de Control
(U.C.), que posee dos registros básicos:
Comparando (C), donde se escribe la información a buscar.
Máscara (M), que dice qué campos del registro queremos comparar. Los
bits no enmascarados del registro C será comparados con los bits corres-
pondientes de todas las celdas de la memoria asociativa.
Los registros Indicadores Ii se ponen a 1 si su registro asociado Ci contiene
la información que se estaba buscando. El Dispositivo de Evaluación de Datos
UNIDAD DE
CONTROL
COMPARANDO C
MASCARA M
CELDA 1 I1
CELDA 2 I2 D
CELDA 3 I3 D
....
....
CELDA N IN
Figura 6.4: Diagrama de Bloques de una Memoria Asociativa
(D.E.D.) es el encargado de informar a la Unidad de Control de las celdas que

contienen la información buscada.
El mecanismo de funcionamiento es el siguiente:
❶ La Unidad de Control pone todos los I i a 1.
❷ Se escribe el registro Comparando.
❸ Se pone el valor que corresponda en el registro de Máscara.
❹ Tras ello, todos los registros indicadores correspondientes a las celdas
cuyo valor, para los bits en los que la máscara valga 1, coincida con el
comparando, se quedarán con el valor de 1 y el resto se pondrán a 0.
Operaciones de búsqueda tı́picas en memorias asociativas son: búsquedas
de extremos (máximos, mı́nimos), de equivalencia (igual a, distinto a), por
umbral (mayor que, menor que) y selecciones de valores ordenados según un
campo (ascendente, descendente).
La principal ventaja de estas memorias estriba en que la complejidad de los
algoritmos mencionados es función del tamaño de las celdas y no de cuántas
celdas estén ocupadas en la memoria. En otras palabras, buscar un número
máximo en una memoria asociativa no depende de cuantos números contenga
la memoria, sino de cuantos bits se utilizan para representar cada número.
6.2.3. Memoria Caché

Es una memora rápida, cara y pequeña. Se encuentra situada entre el proce-
sador y la memoria principal. En principio se puede considerar que funciona
como un buffer de la memoria principal.
CACHE Memoria
CPU
Principal
Figura 6.5: Ubicación de la Memoria Caché
La caché se usa para almacenar una copia de aquellas palabras de la me-

moria principal que están siendo usadas actualmente (y que, según el principio
de localidad son las que se usarán con mayor probabilidad en un futuro cer-
cano), ya que, debido a su reducido tamaño, no podemos almacenar toda la
información que nuestro programa necesita.
Operación
El procesador, cuando tiene que acceder a memoria, siempre mira antes si la
información que busca se encuentra en la memoria caché. Pueden darse dos
posibilidades:
✔ La información solicitada se encuentra en la caché, acierto: se lee/escribe
la copia en caché.
✘ La información solicitada NO se encuentra en la caché (fallo): leo de me-
moria principal la información buscada y guardo una copia en la caché.
A la hora de escribir un nuevo dato en la caché pueden ocurrir dos cosas:
❶ Hay espacio libre en la caché: escribo el dato en alguna de las
posiciones libres.
❷ NO hay espacio libre en la caché: debo buscar qué dato de
los que se encuentran en la caché sustituiré por el que acaba de llegar.
La elección de las palabras a sustituir se realiza según algún criterio:
RAND (Aleatoriamente), FIFO (la que lleva más tiempo en la caché)
o LRU (menos usada recientemente). Si algún dato de los que se van a
sacar de la caché se modificó por el programa, se deberá actualizar la
copia existente en memoria principal, para mantener la coherencia de

caché.
La base del éxito del sistema es la localidad en los accesos durante la ejecución
de los programas. Podemos mencionar los siguientes aspectos que determinan
el rendimiento de la caché:
1. Índice de aciertos o probabilidad de que un dato se encuentre en la caché.
2. Tiempo de acceso a caché.
3. Tiempo de reemplazo.
4. Tiempo consumido en la reparación de las inconsistencias.
Organización
La memoria caché se divide en dos partes, que se representan en la figura
6.6. Consideramos una memoria principal referenciada a nivel de palabra (las
direcciones son direcciones de palabra). Denominamos lı́nea a la unidad básica
de transferencia entre memoria principal y caché. Cada lı́nea se compone de
varias palabras consecutivas de memoria y es la unidad mı́nima de datos que
intercambian caché y memoria principal.
byte 0
palabra 0 Direcciones V M palabra 0 palabra 1
byte 1
línea 0
byte 2 byte 0 byte 1 byte 2 byte 3
palabra 1 línea 0
byte 3
byte 4 línea 1
palabra 2
byte 5 línea 2
línea 1
byte 6
palabra 3
byte 7
byte 8
......
......
byte 9
......
Directorio Caché Zona de Almacenamiento
MEMORIA CACHÉ
MEMORIA PRINCIPAL
Palabras de 2 bytes, líneas de 2 palabras
Figura 6.6: Estructura de una Memoria Caché
El Directorio de la Caché guarda la dirección de comienzo de la lı́nea que

almacena para esa entrada en la caché. Tiene, además, 2 bits por lı́nea: V (Váli-
do, indica si el espacio reservado para almacenar la lı́nea contiene información
válida) y M (Modificación, indica si la lı́nea ha sido modificada). Normalmen-
te, el directorio es una memoria asociativa, de forma que la búsqueda de una
palabra en la memoria caché se hace en paralelo.
La Zona del Almacenamiento es una memoria convencional, de gran velo-
cidad de acceso, que puede guardar tantas lı́neas de memoria principal como
entradas tiene el directorio.
Veamos a continuación un ejemplo de cómo funciona la memoria caché.
Supongamos que en el instante que vamos a tomar como inicial, en la memo-
ria principal se encuentran los datos que aparecen en la Figura 6.7 para las
posiciones indicadas. En este ejemplo, vamos a suponer también que las lı́neas
está formadas por 4 bytes.
Línea
27 0 1 2 3
28
Dirección V M Almacenamiento 29
Línea 0 27 1 0 0 1 2 3 30 7 2 8 9
31 4 1 2 3
1 30 1 0 7 2 8 9
32
2 33 1 1 1 9 5 7 33 1 3 5 7
34
3 31 1 0 4 1 2 3
35
36 9 8 7 6
Memoria Caché
37
38
Memoria Principal
Figura 6.7: Contenidos de la Memoria del Ejemplo
La caché se va a encontrar inicialmente vacı́a, con datos no válidos, por lo

que sus bits Vi van a valer todos 0. A continuación, el procesador realiza una
secuencia de accesos a las lı́neas de memoria siguientes:
27 : Fallo. Almacenar 27 en la Dirección 0, Poner V 0 = 1.
33 : Acierto. La lı́nea está en la caché. Hacemos una escritura en el byte

0, escribiendo un 9 en él, por lo que el bit M se pondrá a 1 (lı́nea
modificada).
30 : Acierto.
31 : Acierto.
27 : Acierto.
36 : Fallo. Habrá que traer su valor de memoria principal a caché. Como la
caché se encuentra ya llena, tendremos que reemplazar alguna lı́nea. La
lı́nea elegida dependerá del algoritmo de reemplazo usado:
* FIFO → se reemplaza la más antigua, la 27.
* LRU → se sustituye la que lleva más tiempo sin referenciar, que en
nuestro caso es la lı́nea 33.
* Aleatorio → se escoge cualquiera de ellas al azar.
En caso de que haya que eliminar la lı́nea 33 de la caché, como se
modificó, antes de borrarla y escribir en su sitio la 36, hay que actualizar
su copia (no válida ya) que existe en memoria principal.
En la figura 6.7 podemos ver el estado de la memoria caché, justo después
de que el procesador escriba en la lı́nea 33.
Visto el funcionamiento básico de una caché, veamos diferentes organiza-
ciones que pueden existir en la zona de almacenamiento. El problema que
queremos resolver es cómo mapear los datos de la memoria principal en la
memoria caché, existiendo para ello diferentes criterios:
Asignación directa: lı́neas consecutivas en memoria principal van a parar
a lı́neas consecutivas en la memoria caché.
Asignación completamente asociativa: las lı́neas de memoria principal
pueden ubicarse en cualquier lı́nea de la memoria caché.
Asignación asociativa por conjuntos: cuando se usa esta estrategia, las
lı́neas de memoria caché se agrupan en conjuntos del mismo tamaño. A
cada lı́nea de memoria principal se le asigna un conjunto, pero dentro
de éste puede ocupar cualquier posición.
Como conclusión sı́ podremos decir que si el número de fallos de caché es
pequeño, la CPU casi esta “viendo” una memoria tan grande como la memoria
principal y tan rápida como la memoria caché. Todo esto a un precio mucho
más razonable que si diseñamos el sistema computador con una caché tan
grande como la memoria principal.
SINOPSIS
La jerarquı́a de memoria surge como consecuencia de la localidad existente

en la ejecución de los programas. En el diseño de esta jerarquı́a hay muchos
parámetros a considerar, pero siempre tendrá un único objetivo: maximizar el
ancho de banda y el tamaño y minimizar el coste. El resultado más remarcable
es que una jerarquı́a de memoria bién diseñada crea la ilusión de constituir
una memoria única tan grande como la memoria principal (o disco duro si
consideramos el nivel de memoria virtual) con el ancho de banda de la memoria
caché. Y todo con con un coste mucho más razonable que el de una prohibitiva
memoria caché del tamaño de la memoria principal o de un disco duro.
7
Entrada/Salida
OBJETIVOS
Recalcar la relevancia de la unidad de Entrada/Salida (E/S)

Distinguir entre E/S mapeada en memoria o por acumulador
Introducir los conceptos de E/S programada, por interrupciones y por
DMA
CAPÍTULO 7: ENTRADA/SALIDA 183
7.1. INTRODUCCIÓN
En los capı́tulos anteriores hemos estudiado la CPU y la memoria. Nos queda

hablar de la E/S. En este capı́tulo no vamos a tratar a los periféricos en sı́,
sino los mecanismos de comunicación con los periféricos.
En la Figura 7.1 encontramos una visión general de un computador, con
los distintos bloques que se conectan al bus: CPU, memoria y los controladores
de los distintos periféricos del computador (impresora, red, etc).
Terminal Red
Memoria
Controlador Controlador
...
CPU
Disco Duro Impresora
Clock
Clock
Figura 7.1: Diagrama de bloques de un sistema basado en procesador
Los periféricos no pueden conectarse directamente al bus por tres motivos:

Sincronización : los periféricos tienen un reloj interno de frecuencia y fase
diferente a la de la unidad central.
Velocidad : el acceso a periféricos es unos 3 órdenes de magnitud más lento
que el acceso a memoria principal.
Codificación : los sistemas de representación de la información en la CPU
son diferentes a los usados por los periféricos.
Por estos motivos, es necesario colocar un controlador entre cada pe-
riférico y el bus. Mediante estos controladores vamos a intentar adecuar la
velocidad de los periféricos a la de la CPU.
Insistimos aquı́ en que un sistema CPU-Memoria no tiene ninguna utilidad
si no puede comunicarse con el exterior, es decir, sin un subsistema de E/S.
Por tanto, si queremos que el sistema completo sea rápido, no bastará con
tener una CPU rápida y un acceso a memoria rápido si es frecuente el acceso
a los periféricos.
Por ejemplo, si los accesos a disco duro son lentos, el sistema completo se
ralentizará, tanto más, cuanto más frecuentes sean los accesos a disco duro.
De nuevo puede aparecer el problema de cuello de botella que manifiesta el
sistema de memoria: el procesador consume los datos a mayor velocidad que

la que los periféricos pueden alcanzar para suministrar esos datos.
7.1.1. Organización
La CPU, memoria y periféricos comparten el bus del sistema, tanto el bus
de datos como el bus de direcciones. A cada unión (interfaz) entre el bus
y el periférico se le llama puerto (de E/S). Es la “puerta” a través de la
cual accedemos a los controladores (y, por tanto, a los periféricos que tienen
asociados). Fı́sicamente, un puerto de entrada/salida no es más que un registro
que puede ser leı́do por la CPU (y escrito también en muchos casos).
Para poder seleccionar qué puerto queremos leer (volcar su contenido al
bus de datos), asignamos a cada uno de los puertos una dirección única. De
esta forma, para leer el contenido de un puerto, primero lo direccionamos
(colocando en el bus de direcciones su dirección particular) y luego leemos su
contenido.
En la figura 7.2 podemos ver un esquema de este sistema, incluyendo los
controladores y puertos. Como se puede observar, podemos tener más puertos
que periféricos. En esta figura no hemos incluido las lı́neas de control, ya que
en función del conexionado de este bus de control tendremos dos posibles
configuraciones que veremos a continuación.
DATOS
CPU DIRECCIONES
Puerto Puerto Puerto
Periférico Periférico
Figura 7.2: Esquema general de un sistema basado en procesador y sus pe-

riféricos
a) E/S mapeada en E/S o por acumulador

En este caso tendremos diferentes señales de control para la memoria y para
los puertos. Es decir, en cierto sentido, el bus de control está dividido: unas
lı́neas son para el control de los dispositivos de memoria, mientras que otras
lı́neas se dedican al control de los periféricos.
Por ejemplo, en la figura 7.3 vemos como la lı́nea de selección de lectu-
ra/escritura en memoria es distinta de la lı́nea de lectura/escritura en alguno
de los puertos.
Datos
Direcciones
IOR/W
0 Puerto 1 Puerto 2 Puerto
0
1
R/W Controlador Controlador
2 Memoria CPU Periférico Periférico
(a) Diagrama de Bloques
Mapa de Memoria
0
Mapa de E/S
0
2 m- 1
2 n- 1
(b) Mapa de Direcciones
Figura 7.3: E/S Mapeada en E/S
De esta forma, según la señal de control que se active (R/W ó IOR/W), sa-
bremos a quién hacen referencia las direcciones del bus de direcciones. Esta si-
tuación, llevada al nivel del lenguaje ensamblador del procesador, se traduce en
que tendremos diferentes instrucciones para transferencia de datos dependien-
do de que las transferencias sean entre CPU/memoria o entre CPU/periféricos.
Por ejemplo, en los micros de Intel la instrucción MOV se utiliza para transferen-
cias con memoria, mientras que las instrucciones IN y OUT para transferencias
con puertos de E/S.
El mapa de memoria o mapa de direcciones representa el rango de
direcciones válidas que puede colocar la CPU en el bus. Dado que existen
direcciones de memoria y direcciones de puertos de E/S, tendremos mapas de
memoria independientes para cada uno de los conjuntos de direcciones.
En la E/S por acumulador, al poder distinguirse un acceso a memoria de
otro a periférico gracias a que las señales de control son independientes, los
mapas de memoria pueden solapar parte de su espacio de direcciones. Por
ejemplo, en las arquitecturas con procesadores Intel, la parte más baja de los
espacios de direcciones pueden corresponder tanto a direcciones de memoria
como de E/S.
b) E/S mapeada en memoria

En este caso, la memoria y los puertos tienen las mismas señales de control,
es decir, y volviendo al ejemplo anterior, sólo dispondremos de una señal de
lectura/escritura (R/W). Por tanto, las instrucciones de transferencia de da-
tos en ensamblador serán las mismas para ambos tipos de transferencia. Por
ejemplo, en los procesadores de Motorola, la instrucción MOVE se puede utili-
zar tanto para lectura/escritura de posiciones de memoria como de puertos de
E/S.
De esta forma, si queremos distinguir entre un acceso a memoria y un
acceso a periférico, debemos asignar rangos de direcciones disjuntos a ambos
tipos de dispositivos. Es decir, en un sistema con E/S mapeada en memoria, el
espacio de direcciones de E/S no se puede solapar con el espacio de direcciones
de posiciones de memoria, como vemos en la figura 7.4.
Para terminar esta sección de introducción, vamos a enumerar las distintas
estrategias existentes para comunicar una CPU con sus periféricos. Éstas serán
estudiadas a continuación en las próximas secciones. Por orden de complejidad
ascendente, estas técnicas son:
E/S dirigida por programa.
Interrupciones.
Acceso Directo a memoria (DMA).
7.2. E/S DIRIGIDA POR PROGRAMA
Esta es la técnica más simple para controlar operaciones de E/S. Al mismo

tiempo, y como es de esperar, también es la técnica menos eficiente y lenta
para transferencia de información con periféricos.
La idea es que la CPU controle totalmente las operaciones de E/S. La
CPU tiene, por tanto, que ejecutar programas para iniciar, dirigir y finalizar
Datos
Direcciones
R/W
Puerto Puerto Puerto
Memoria CPU Periférico Periférico
(a) Diagrama de Bloques
Memoria
2n - 1
2n
E/S
2 n+m -1
(b) Mapa de Direcciones
Figura 7.4: E/S Mapeada en Memoria
las operaciones de E/S. Veámoslo a través del siguiente ejemplo. Supongamos

que la CPU está leyendo un fichero del disco duro (HD), y que este dispositivo
presenta una controladora con dos puertos de un byte (A y B). El puerto A
(con dirección 15) será el puerto de datos, es decir, el puerto que lee la CPU
cuando la controladora ha leı́do un byte del HD y lo ha escrito en ese puerto.
Para indicar que el puerto A tiene un byte válido, la controladora pone el bit
0 del puerto B (dirección 16) a uno.
Con esta situación, y partiendo de que inicialmente el bit 0 del puerto B,
B(0), está a 0, el proceso de lectura de fichero dirigido por programa consta
de las siguientes fases:
1. Seleccionar el puerto B, es decir, colocar en el bus de direcciones la
dirección 16.
2. Leer el bit 0 del puerto B, hasta que el bit sea uno. A esta operación se
le llama espera activa. Se dice que la espera es activa porque la CPU

está ejecutando instrucciones para leer el bit 0 del puerto B hasta que
esté a uno.
3. Una vez sabemos que hay un byte válido en el puerto A, lo direccionamos
(ponemos en el bus de direcciones la dirección 15) y leemos del bus de
datos. Guardaremos el byte en un registro temporal de la CPU.
4. A continuación, realizamos la transferencia entre el registro de la CPU
y alguna posición de memoria.
5. Si no hay más transferencias terminamos, y, si no, volvemos al paso 1.
Las principales ventajas de este sistema son su bajo coste hardware y su
simplicidad. Presenta el problema de las bajas velocidades conseguidas y de
la ralentización del procesador en la espera activa.
7.3. INTERRUPCIONES
Una interrupción es un mecanismo que permite a la CPU ser sensible a

estı́mulos diferentes a los creados por sus operaciones internas y, en particular,
a los generados por los dispositivos de E/S. Mediante este mecanismo, una
vez que la CPU indica a algún dispositivo de E/S qué tarea debe realizar, se
desentiende de éste. La CPU puede realizar mientras otras tareas, hasta que el
periférico le avise de que ha completado la operación que se le habı́a encargado.
Para “avisar” a la CPU se utiliza su señal de petición de interrupción. Como
vimos en el tema 3, cuando la señal de interrupción de la CPU se activa, ésta
ejecuta una rutina llamada rutina de tratamiento de interrupción, en la
que la CPU atiende al periférico que la ha interrumpido.
7.3.1. Clasificación de las Interrupciones

Interrupción Hardware : se generan cuando hay fallos en el hardware del
computador, tales como errores de paridad, falta de suministro de po-
tencia, ... Son de muy alta prioridad. No son enmascarables, es decir, no
se puede inhibir la ejecución de la rutina de interrupción correspondiente
una vez se produce la interrupción.
Interrupción Software : producida por cualquier causa excepcional durante
la ejecución de un programa: overflows, división por 0, código de opera-
ción ilegal, ...
Interrupción Temporal : son interrupciones cı́clicas, generadas por el reloj
del sistema. Tienen prioridad alta. Un uso común es la medición de
tiempos en la CPU.
Interrupción de E/S : son generadas por los periféricos, para solicitar la

atención de la CPU en ciertas situaciones. Por ejemplo, pueden indicar
que ha terminado una acción de E/S (como localización de una posición
en una cinta, posicionamiento del brazo móvil de un disco duro, etc, ...).
7.3.2. Operación
Supongamos que queremos leer un fichero del disco duro. A partir del nom-
bre del fichero, el sistema operativo puede determinar en qué pista y sector
comienza. Para empezar a leer bytes (su contenido) es necesario posicionar
previamente el cabezal de lectura del HD en el lugar adecuado. El tiempo
necesario para realizar esta operación (tiempo de acceso) es de varios milise-
gundos. Está claro que mantener la CPU sin hacer nada (o realizando una
espera activa) durante varios milisegundos resulta en una pérdida de eficiencia
del sistema.
Por tanto, resulta más interesante permitir que la CPU ejecute otras ins-
trucciones mientras el controlador del HD se encarga de posicionar el cabezal.
Cuando esta operación termine, el controlador enviará una señal de interrup-
ción a la CPU. Ésta señal, activará algún bit de un registro interno a la CPU.
Por su parte, la CPU chequea este bit antes de ejecutar una nueva instrucción
y, si lo encuentra a uno, realiza la siguiente secuencia de operaciones:
1. Resetea el bit e indica al controlador que estamos atendiendo su inte-
rrupción.
2. Deshabilitar la posibilidad de que se nos pueda interrumpir de nuevo
mientras estamos atendiendo a este periférico (no se vuelve a mirar el
mencionado bit, aunque se ponga a uno).
3. Transferir el control a una posición DirRTI de memoria (donde se en-
cuentra la rutina de tratamiento de la interrupción que estamos atendien-
do), guardando previamente el contador de programa (PC) en PCAc-
tual.
4. Ejecutar la rutina de tratamiento de interrupción:
❶ Salvar el estado del procesador (SR, puntero de pila, registros de
propósito general, etc...)
❷ Leer el fichero.
❸ Restaurar el estado del procesador (recupera SR, puntero de pila,
registros de propósito general, etc...).
5. Volver a habilitar las interrupciones.
6. Seguir la ejecución del programa por donde se quedó antes de ser inte-
rrumpido, es decir, recuperar el antiguo valor del P C ← (P CActual).
7.4. ACCESO DIRECTO A MEMORIA
Aunque la técnica de interrupciones elimina el problema de la espera activa,

aún queda para el procesador la tarea de ir leyendo datos de los dispositivos de
E/S y de ir escribiéndolos en memoria. Ésta tarea es tan rutinaria y simple, que
estamos desperdiciando la potencia de cálculo de un procesador si lo tenemos
ocupado con este tipo de programas. La solución a este problema consiste en
incluir en el sistema computador un dispositivo que se encargue de realizar
estas transferencias: el dispositivo de Acceso Directo a Memoria(DMA).
7.4.1. Organización
En la figura 7.5 encontramos un diagrama de bloques con la configuración de
un sistema que incluye DMA. Como puede observarse, el DMA, y al contrario
que los demás dispositivos, puede leer y escribir tanto en el bus de datos
como en el de direcciones. Este dispositivo va a funcionar como un esclavo de
la CPU (o coprocesador para operaciones de E/S), realizando las tareas de
transferencia de E/S que le indique la CPU. El significado de las señales lo
veremos más adelante, al hablar de su modo de operación.
Datos
Direcciones
Puerto
RE
Controlador
ACK
CPU Memoria DMA Periférico
Control
BR
BG
BGACK
Figura 7.5: Esquema del DMA
7.4.2. Operación
Supongamos que queremos cargar un fichero en memoria. La CPU progra-
mará el DMA para que este dispositivo se encargue de la lectura del fichero y
su almacenamiento en memoria. Mientras, la CPU puede dedicarse a ejecutar

otro tipo de programas. Cuando el DMA termina, lo indicará a la CPU (me-
diante una señal de interrupción) para que sepa que ya están disponibles en
memoria los datos que pidió.
Con más detalle, son necesarios los siguientes pasos:
1. La CPU direcciona al DMA como si fuese un periférico más, para indi-
carle que quiere “hablar” con él. Por el bus de datos, la CPU le transfiere
al DMA la información que necesita para realizar la transferencia, escri-
biendo para ello en los registros internos del DMA:
❶ Dirección de memoria en la que almacenar el fichero.
❷ Dirección, en el disco duro, en la cual se encuentra almacenado el
fichero.
❸ Sentido de la operación, es decir, si es lectura o escritura de HD
(lectura en nuestro ejemplo).
❹ Longitud del bloque a transmitir (número de bytes del fichero).
2. El DMA hace la transferencia, leyendo los datos del disco y direccionando
posteriormente la memoria para escribir en ella cada byte. Para ello
necesita el BUS (tanto de datos como de direcciones y, a veces, también
el de control), que podrá usar en los momentos en que la CPU no acceda
a la memoria (porque esté trabajando con registros, caché, coprocesador,
etc.). Para pedir el bus a la CPU usa un protocolo de tipo handshaking
(“estrechamiento de manos”), mediante la secuencia de señales: BR (Bus
Request, petición del bus), BG (Bus Grant, cesión del bus) y BGACK
(Bus Grant ACKnowledge, reconocimiento de cesión del bus). Tras esta
última señal, el DMA dispone del bus para uso propio.
3. Cuando el DMA termine, mandará una interrupción a la CPU para
indicarle que ha acabado y que ya puede disponer en memoria de los
datos que le pidió.
A la hora de realizar las transferencias, existen varios modos de operar. Por
ejemplo, dependiendo de cómo se repartan el uso de bus la CPU y el DMA
tenemos:
Bloques sin ruptura: si el DMA tiene el bus, no lo suelta hasta que ter-
mina la transferencia de un bloque completo. La CPU tiene que esperar
a que el DMA libere el bus.
Ciclo a ciclo: DMA y CPU se reparten ciclo a ciclo el control de bus
(uno para la CPU y otro para el DMA, alternando).
Ciclos muertos de CPU: el DMA solo tomará control del bus cuando
se dé cuenta de que la CPU no lo está utilizando.
Controlado por el periférico: el periférico es el que decide cuando se

hace la transferencia.
Otro dispositivo más potente para realizar operaciones de E/S son los
Canales de Entrada/Salida, que son coprocesadores, con varias DMAs en
su interior, que pueden ser programados, y con más inteligencia que los DMAs.
SINOPSIS
Hemos visto la evolución de la Entrada/Salida desde la E/S programada hasta

el DMA, mencionando también los Canales de E/S. Hemos podido comprobar
como un incremento del hardware, con su consecuente aumento del coste del
sistema computador completo, permite realizar operaciones de comunicación
de E/S cada vez más eficientes.
8
Introducción a los
Sistemas Operativos
OBJETIVOS
Identificar las tareas de las que es responsable el Sistema Operativo

(S.O.) en un computador
Comprender los mecanismos implicados en la gestión de sistemas de
tiempo compartido, multiusuario y multitarea
Completar con el nivel de memoria virtual la descripción de sistemas con
jerarquı́a de memoria
CAPÍTULO 8: INTRODUCCIÓN A LOS SISTEMAS OPERATIVOS 195
8.1. INTRODUCCIÓN
Un Sistema Operativo (S.O.) se puede definir como un conjunto de progra-

mas que permiten utilizar el hardware de la máquina, a uno o varios usuarios,
de una manera sencilla y eficiente.
Vamos a ver un poco más detenidamente esta definición. Un S.O. es un
conjunto de programas, es decir, algo Software o Firmware (software que no
se puede modificar, como microsubrutinas o programas residentes en ROM),
cuya misión es facilitar la gestión del hardware. En principio, se dedicará al
control de los dispositivos de Entrada/Salida, como pueden ser el disco duro,
CD-ROM, vı́deo,... El procesador también es parte del hardware, por lo que
será otro recurso más a gestionar, sobre todo cuando hay más de un usuario
usándolo a la vez.
El S.O. controla todo el hardware con el objetivo de que la máquina dé un
rendimiento óptimo, de modo que, si un usuario o aplicación quiere utilizar
el hardware, será mediante llamadas a las rutinas del S.O. Se habla de una
estructura en capas (figura 8.1), en la que el S.O. oculta los dispositivos hard-
ware (disco, puertos de E/S...), proporcionando a las aplicaciones (procesos)
un interfaz más sencillo. El proceso solicita estos servicios haciendo llamadas
al S.O., que maneja el hardware mediante el uso de interrupciones.
Aplicaciones
S.O.
Hardware
Figura 8.1: Capas de un S.O.
8.1.1. Tareas que realiza un Sistema Operativo

Un S.O. debe suministrar los medios para poder llevar a cabo las siguientes
operaciones:
Concurrencia o capacidad de poder realizar varias actividades simul-
táneas, como el solapamiento de actividades de E/S con computación en
el procesador.
Interfaz con el usuario, es decir, establecer los mecanismos de comu-
nicación entre el usuario y el hardware.
Compartición de recursos ya que las actividades concurrentes, que
se ejecutan a la vez, pueden compartir recursos hardware e información.
Entre estos recursos se incluye procesador(es), memoria, E/S y comuni-
caciones (p.e. conexión a la red).
Almacenamiento a largo plazo (sistema de ficheros) dada la necesi-
dad de los usuarios de guardar sus datos en el computador para usos
posteriores.
Protección, pues, aunque habrá elementos que compartir, otros serán
privados y deberán ser de acceso restringido.
El sistema operativo ha de responder de forma adecuada, independien-
temente de las situaciones impredecibles que pudieran tener lugar. Es
importante que el S.O. pueda realizar recuperación de errores.
Además de implementar estas funcionalidades, serı́a deseable que el S.O.
fuera eficiente, fiable, fácil de corregir o modificar, y que no ocupe excesivos
recursos (p.e. espacio en disco duro, memoria, etc.).
8.1.2. Evolución de los Sistemas Operativos

La historia de los Sistemas Operativos se puede dividir en una serie de gene-
raciones, cada una caracterizada por introducir alguna novedad.
Las primeras máquinas carecı́an de S.O. Los usuarios programaban en
código máquina y todas las funciones tenı́an que ser programadas por ellos
mismo a mano (1940-50). Además, se perdı́a mucho tiempo entre la conclusión
de un trabajo y el comienzo del siguiente. De forma sintética los pasos en la
evolución de los S.O han sido:
1. Creación de los primeros S.O. (1950) constituidos por programas a los
que se les pasaban un conjunto de trabajos por lotes o batch (.BAT en
el MS-DOS). El S.O. estaba diseñado para ir ejecutando cada uno de los
trabajos uno a uno. Al terminar cada trabajo (normal o anormalmente),
el control se devolvı́a automáticamente al S.O., que iniciaba el trabajo
siguiente.
2. Con la introducción de la multiprogramación en los años 60, la entra-
da/salida se comenzó a realizar en paralelo con la computación, apro-
vechándose mejor el procesador.
3. Aparición del procesamiento en tiempo compartido, donde la máquina es
capaz de ejecutar programas de varios usuarios. Ésto se hace de modo que

no sólo se comparten los recursos, sino que además se tiene la sensación
de que la máquina la estamos usando sólo nosotros. Ası́ se explota el
procesador de un modo en el que se obtiene un mayor rendimiento. Para
ello, el S.O. asigna pequeños intervalos de tiempo de CPU (“time slices”
o quantum de tiempo) a cada usuario.
4. La complejidad de los S.O. crece dı́a a dı́a, especialmente con los sistemas
multiprocesador, en los que se debe dividir eficientemente las tareas a
realizar entre los procesadores que tenga disponibles el computador.
8.2. ADMINISTRACIÓN Y PLANIFICACIÓN DE PROCE-

SOS
8.2.1. Proceso
Proceso es cualquier programa que el S.O. haya cargado e iniciado, asignán-
dole los recursos del sistema que necesite (espacio de direcciones de memoria
virtuales y fı́sicas, variables de entorno, archivos, ...), y aspire a ser ejecutado
en la CPU cuando sea posible. Observar que el S.O. se compone de varios
programas que se ejecutan y son, por tanto, procesos.
El sistema operativo necesita almacenar ciertos datos sobre cada proceso,
para poder realizar sobre ellos ciertas operaciones que veremos más adelante.
La estructura de datos que se usa para guardar la información relativa a un
proceso se denomina PCB (Bloque de Control de Proceso) y contiene, entre
otros, los siguientes valores:
Estado actual del proceso
Identificador (PID, un número) que es único para cada proceso
Posición de memoria en donde se encuentra el código del proceso
Identificación del proceso padre (el que lo creó)
Identificación de los procesos hijos (los que él cree)
Información de los recursos que le han sido asignados
Prioridad del proceso, etc...
La forma en que el sistema operativo gestiona los programas en ejecución
dependerá de si éste permite o no tener varios procesos usando el procesador
simultáneamente (procesamiento en tiempo compartido o procesos concurren-
tes):
Un S.O. monotarea y monousuario, como MS-DOS, sólo carga en memo-
ria un único programa, pasándole el control a éste, que se ejecutará de
forma exclusiva en el procesador. El programa cargado será el responsa-

ble devolver el control al S.O cuando termine su ejecución. En MS-DOS,
al conjunto de interrupciones encargadas de ofrecer al programa de usua-
rio los servicios de E/S se le denomina BIOS (Basic Input Output System
o sistema de E/S básico).
Un S.O. multitarea es capaz de ejecutar a la vez varios procesos. Para ello,
hemos de disponer de una interrupción temporal que se active periódi-
camente. Con esta interrupción, se invocará al S.O., que conmutará el
uso de la CPU entre los diferentes procesos que se estén ejecutando. De
esta manera, se da la impresión de que se están corriendo simultánea-
mente varios programas en la CPU. El quantum de tiempo o time-slice
es el tiempo que transcurre desde que el procesador empieza a atender
a un proceso hasta que deja de hacerlo, para pasar a tratar el siguiente.
Cada uno de los procesos se comporta como si tuviera su propio puntero
contador de programa (PC) y puntero de pila (SP).
UNIX y VMS son ejemplos de sistemas operativos que hace ya mucho
tiempo que ofrecen multitarea.
Sistemas operativos como Windows 3.x ofrecen lo que se denomina mul-
titarea cooperativa o no-prioritaria que no es una verdadera multitarea. En
este esquema es cada tarea la que es responsable de pasar el control al núcleo
del sistema operativo para que conmute a otra. Si una tarea no hace esto es
imposible conmutar (pudiendo quedar colgado).
En Windows 9x, NT la multitarea es prioritaria es decir se realiza una
conmutación entre procesos cada cierto tiempo. Además existe un proceso
encargado de emular la ejecución de todas las aplicaciones de Windows 3.x
que implementan la multitarea no-prioritaria. Este proceso sólo se ejecuta
durante su time slice.
Un término que encontramos en los S.O. actuales es el de thread, que
encontramos traducido por subproceso, hebra o hilo. Con un significado análogo
al de proceso, los threads tienen la propiedad de poder compartir recursos entre
sı́, como por ejemplo el rango de direcciones de memoria asignadas.
8.2.2. Estados de un Proceso

En un sistema multitarea, un proceso se puede encontrar en tres estados dis-
tintos:
a) RUNNING (en ejecución): cuando el proceso se está ejecutando (está sien-
do atendido por la CPU, o usando la CPU).
time slice=10ms.
proceso 1 proceso 2 proceso 3 proceso 1 ......................
memoria
procesador subproceso a
proceso1
subproceso b
proceso2
proceso 3
Figura 8.2: S.O. Multitarea
b) READY (listo): el proceso podrı́a estar en ejecución si la CPU estuviese

libre, es decir, si ésta no estuviese ejecutando otro proceso.
c) BLOCKED (bloqueado): el proceso está a la espera de que ocurra algún
evento, normalmente alguna transacción de Entrada/Salida.
En sistemas monoprocesador sólo puede haber un proceso running, pero
varios ready y blocked. El sistema operativo tiene una lista con los procesos
ready (ordenados por prioridad) y otra con los procesos blocked (en este caso
la lista está desordenada).
Las transiciones entre estos estados se producen mediante llamadas del
sistema operativo a una serie de funciones, con el nombre del proceso como
parámetro, excepto en el caso del paso de running a blocked, que es provocada
por el propio proceso cuando necesita realizar una operación de E/S. Las
posibles transiciones entre estados de un proceso aparecen representadas en la
figura 8.3 y se comentan a continuación.
RUNNING
block
dispatch
Timer_run_out
READY BLOCKED
wake-up
Figura 8.3: Estados de un proceso
Dispatch: se produce cuando un proceso toma posesión de la CPU, debido

a que el que la estaba usando ha agotado su tiempo de uso (quantum)
o ha terminado su ejecución. El proceso que se apropiará de la CPU
será el primero de la lista de procesos ready. El sistema operativo de-
berá almacenar el nuevo estado de los procesos del sistema, pues se ha
producido lo que se denomina un cambio de contexto (cambio del proceso
en ejecución).
Timer run out: el sistema operativo asigna a cada proceso un tiempo fijo
(quantum) de uso de la CPU. Si en ese tiempo no es capaz de terminar
lo que le quedaba cuando tomó posesión de la CPU la última vez, se
activa el Timer run out (una interrupción temporal), con la que se obliga
al proceso que estaba running a abandonar la CPU, pasando a estado
ready.
Block: es el otro motivo por el que un proceso puede dejar libre la CPU.
Cuando un proceso llega a una instrucción que ha de esperar a que
se complete una operación de E/S, éste (para evitar estar ocupando la
CPU durante la operación de E/S) pasa a estado blocked y libera la
CPU. Esta transición la provoca el propio proceso cuando debe esperar
a que se produzca algún evento de E/S.
Wake up: esta señal se envı́a a un proceso que está blocked cuando se ha
producido el evento de E/S que le hizo pasar a este estado. Como ya no
tiene que esperar nada más para continuar su ejecución, pasa a la lista
de procesos ready, esto es, listos para seguir su trabajo.
Vamos a ver un par de ejemplos de cómo funciona esto. Supongamos que
tenemos tres procesos, que llamaremos A, B y C, que se van a ejecutar concu-
rrentemente usando la misma CPU. El quantum (Q) de tiempo que asigna el
sistema operativo a cada proceso será de 10 milisegundos. Veremos que ocurre

a lo largo del tiempo para las dos situaciones que aparecen en la figura 8.4.
a) A=30 B=10 C=20 Q = 10

10 10 10 10 10 10
A B C A C A
b) A=30 B=25 C=20
5 10 10 10 10 10 5 10 5
A B C B C A B A A
block A wake-up A
Figura 8.4: Ejemplos de transición entre estados de un proceso
En el primer ejemplo, los procesos tardan 30, 10 y 20 milisegundos respec-

tivamente en ejecutarse. En este caso no habrá operaciones de Entrada/Salida,
por lo que cada proceso irá tomando durante 10 mseg. la CPU, realizará las
operaciones que pueda en ese tiempo y dejará libre el procesador para el si-
guiente proceso. Los diferentes procesos, al no haber ninguno prioritario, irán
apropiándose de la CPU cı́clicamente, mientras no hayan terminado su trabajo
(ver figura 8.4.a).
Para el segundo caso, vamos a suponer que los procesos van a necesitar
utilizar 30, 25 y 20 milisegundos la CPU. Ahora, cuando el proceso A lleve 5
milisegundos, va a tener que leer de un fichero y no podrá seguir su ejecución
hasta tenerlo cargado en memoria, por lo que el proceso pasará a estado bloc-
ked. Previamente, antes de bloquearse, programará el DMA para que realice
la transferencia y, cuando ésta termine (30 milisegundos después), el DMA
avisará mediante una interrupción. Cuando esto ocurra, el proceso pasará a la
lista de procesos ready, para que continúe su ejecución en el momento que le
corresponda usar la CPU. La figura 8.4.b representa esto esquemáticamente.
Al hablar de los posibles estados de un proceso y sus transiciones, hemos
visto como cuando se produce el Timer run out, realmente lo que está ocu-
rriendo es una interrupción temporal. Desde el punto de vista de un S.O., la
interrupción es un suceso que altera la secuencia normal de ejecución de un
proceso. Cuando se activa una interrupción de éste tipo, se llevan a cabo una
serie de acciones:
❶ El sistema operativo toma el control
❷ El S.O. salva el estado del proceso en ejecución (en el PCB)
❸ El S.O. analiza la interrupción y le pasa el control al proceso (rutina)

adecuado de manejo de esa interrupción
❹ El proceso de tratamiento de la interrupción realiza su trabajo
❺ El S.O. restaura el estado del proceso interrumpido y éste continúa eje-
cutando por donde se quedó
Las interrupciones se pueden anidar, es decir, un proceso de tratamiento de
interrupción puede a su vez ser interrumpido y ası́ sucesivamente.
Cada vez que un proceso tiene que salir de la CPU para que entre otro,
se produce lo que se denomina un cambio o conmutación de contexto, que
consiste en salvar el estado del proceso en ejecución, antes de que entre el
nuevo proceso.
8.2.3. Planificación
La planificación (processor scheduling) es el mecanismo, que implementan los

S.O., para asignar procesos a los procesadores. El planificador (scheduler) da
las prioridades a los procesos en la cola de procesos ready. Hay dos formas en
las que se puede asignar un procesador a un proceso:
No Preemptive (no expropiativa, no prioritaria o cooperativa) → si un pro-
ceso toma la CPU, nadie le podrá interrumpir hasta que termine, o le
ceda el control al S.O.
Preemptive (expropiativa o prioritaria) → en tiempo compartido, cuando
transcurre el quantum de tiempo, se producirá una interrupción del reloj,
saliendo de la CPU el proceso que la tenı́a y entrando en su lugar el
primero en la lista de procesos ready.
La forma en que el scheduler asigna las prioridades a los diferentes procesos
de la lista de procesos ready da lugar a varios algoritmos de planificación,
que pasamos a ver a continuación:
FIFO (cola), el primero que llega es el primero en salir, es de tipo no
preemptive.
Round Robin (RR), es una FIFO preemptive.
Shortest-Job-First (SJF) da más prioridad a los procesos más cortos.
Con esta polı́tica se consigue una mayor razón de ejecución de trabajos.
Highest-Response-Ratio-Next (HRN) (el siguiente con relación de
respuesta máxima). Las prioridades que se asignan son dinámicas, con
lo que mejoramos el algoritmo SJF. La prioridad en un momento deter-
minado viene dada por la expresión:
tiempo esperando + tiempo de ejecución

prioridad =
tiempo de ejecución
En principio, los procesos cortos tienen mayor prioridad. Los proce-

sos largos, al tener que esperar más, irán aumentando poco a poco su
prioridad.
8.2.4. Operaciones sobre Procesos

Sobre un proceso se pueden realizar un gran número de operaciones, como
crear, destruir, suspender, reanudar, cambiar la prioridad, bloquear, despertar,
etc...
Crear. Cuando se crea se realizan una serie de operaciones:
Dar un nombre al proceso
Introducirlo en la lista de procesos conocidos
Determinar la prioridad inicial
Crear su PCB
Asignar los recursos iniciales
Un proceso puede a su vez crear otro(s) proceso(s). Al proceso crea-
dor se le llama proceso padre y a los creados procesos hijo(s).
Aniquilar. Cuando esto sucede, se borra del sistema, se liberan los recursos
que hubiese ocupado y se elimina su PCB correspondiente.
Suspender y Reanudar. Cuando se observa alguno de los sı́ntomas siguien-
tes en un sistema, se suele suspender el proceso(s) que se sospecha que
es el causante:
El sistema va lento
Un proceso actúa de forma sospechosa
El sistema está muy cargado
Cuando se vuelve a la normalidad, se suele reanudar a los procesos
que estuviesen suspendidos.
Núcleo del S.O. (KERNEL)

Hay una parte del código del sistema operativo que es la que más se suele
usar. Esta parte reside en memoria principal y se denomina núcleo del sistema
operativo.
Entre otras, las funciones más importantes de este código son:
Crear y destruir procesos
Dispatching, suspensión, reanudación,... de procesos

Manejar los PCB de los procesos (y gestionar los cambios de estado en
general)
Manejar interrupciones y la sincronización
Realizar actividades de Entrada/Salida
Asignar y liberar recursos (p.e. memoria)
Soportar el sistema de ficheros
8.3. MEMORIA VIRTUAL
Hemos visto como el S.O. es el encargado de gestionar los recursos del sistema.
Entre ellos, la memoria es uno de los más importantes que debe administrar.
Imagı́nese que quisiésemos usar un rango de direcciones de memoria mayor del
que fı́sicamente tenemos, sin incrementar el hardware. Las posibles soluciones
propuestas por orden cronológico, en la historia de la computación, son:
Conmutar bancos de memoria entre sı́, controlándolos con un registro, de
forma que en un momento dado las direcciones sólo se refieren al banco
seleccionado. Es una solución lenta y cara.
Overlays (recubrimientos). Son definidos por el programador. En ellos,
la información se va cargando conforme se va necesitando, no de una sola
vez al principio del programa (en MS-DOS son los ficheros con extensión
.OVL).
Memoria Virtual. En este caso se usa la memoria principal como “caché”
de la memoria secundaria (disco duro).
La memoria virtual surge, por tanto, por la necesidad de ejecutar progra-
mas que usan una cantidad de memoria superior a la que se tiene fı́sicamente.
Para ello, habrá que desarrollar mecanismos eficientes para la compartición de
la memoria principal.
Al trabajar con la memoria virtual, nos vamos a encontrar con una termi-
nologı́a básica:
Página: bloques elementales con los que se trabaja en las transferencias
entre memoria principal y secundaria.
Fallo de Página (miss o page fault): se produce cuando el programa hace
referencia a una dirección de memoria que no se encuentra entre las
direcciones actualmente cargadas en memoria principal. En este caso,
habrá que traer de memoria secundaria la página que la contenga. Si
en memoria principal no quedase sitio suficiente para almacenarla, se
deberá elegir (siguiendo alguna polı́tica) la página a la que reemplazará.
Si esta hubiese sido modificada por el programa, se deberá salvar la copia

actualizada en el disco.
Dirección Virtual / Dirección Fı́sica. La dirección virtual es la que usan
los programas, dentro del espacio de direcciones de la memoria virtual.
La dirección fı́sica es la dirección en la que realmente se almacenan los
datos en memoria principal.
Traducción de Direcciones (memory mapping): es el mecanismo por el
que asignamos a una dirección virtual una dirección fı́sica.
A la hora de diseñar una memoria virtual, los aspectos a tener en cuenta
vienen motivados por el alto coste de un fallo de página. Los más importantes
son:
Tamaño de la página (mismas consideraciones que el tamaño de lı́nea en
la caché), suele ser de 4K ó 16K.
Gestión de los fallos de página. Son tratados por software, pues hay
tiempo suficiente para ello y de este modo se puede hacer de un modo
más inteligente.
8.3.1. Ejemplo
Vamos a ver, para terminar, un ejemplo con valores numéricos de un sistema
de memoria virtual. El sistema de nuestro ejemplo va a trabajar con páginas
de 4 Kbytes de tamaño. La memoria fı́sica tendrá un tamaño de 4 Megabytes
y el espacio de direcciones virtual será de 4 Gigabytes. En este caso:
Tamaño de página =212 = 4Kbytes = P
Tamaño de Mem. Real =222 = 4M bytes = M → 210 páginas
Tamaño de Mem. Virtual =232 = 4Gbytes = V → 220 páginas
En la figura 8.5 podemos ver los campos en que se dividen las direcciones,
tanto virtuales como fı́sicas. En ambos casos, los 12 bits menos significativos se
usan para dar el desplazamiento dentro de la página. El espacio de direcciones
virtuales tiene 220 páginas, mientras que el fı́sico sólo consta de 2 10 , por lo
que se deberá establecer un mecanismo para traducir las páginas virtuales en
fı́sicas. Para ello se usa una tabla como la que puede observarse en la figura
8.5.
Esta tabla tendrá 220 entradas, una por cada página de memoria virtual,
y cada entrada nos dirá si la página en cuestión se encuentra cargada en
memoria y, en este caso, en qué posición fı́sica (para indicarlo necesitará 10
bits), o si, por el contrario, está almacenada en memoria secundaria y dónde.
En caso de que se encuentre en memoria principal, un bit de modificación M
32 bits -> dirección memoria virtual
pv w
20 bits -> página 12 bits -> desplazamiento
1 pr pr w
22 bits -> dirección real
bit de presencia
Figura 8.5: Traducción de referencia virtual a real
nos indicará si la página en memoria ha sido modificada o se encuentra como

en el momento en que se trajo a memoria principal.
Como se puede apreciar en este ejemplo, utilizar una tabla con tantas
entradas como páginas virtuales da lugar a grandes tamaños para la tabla.
Para paliar este problema, se riza un poco más el rizo y se pagina a su vez la
tabla de páginas. Es decir, la tabla se parte en páginas y sólo tendremos en
memoria las páginas de la tabla que estén siendo utilizadas. Siguiendo con el
mismo ejemplo, para un espacio de direcciones virtual de 32 bits, una posible
implementación para la tabla de traducción aparece representada en la figura
8.6.
Podemos observar como el cálculo de la dirección fı́sica se hace en dos
fases. En un primer paso usamos los 8 bits más significativos para elegir la
tabla de traducción a usar dentro de un directorio de tablas. A partir del
valor ası́ obtenido, que será la dirección base de la tabla de traducción a
usar, los siguientes 12 bits nos seleccionarán la entrada adecuada dentro de
la tabla de traducción. Esta tabla nos dará como salida la dirección base
de la página que estamos buscando, por lo que si le sumamos los 12 bits
restantes (desplazamiento dentro de la página), obtendremos la posición fı́sica
correspondiente a nuestra dirección virtual.
Este método presenta una serie de problemas:
a) Son necesarios dos accesos a memoria para realizar la traducción, por lo
32 bits -> dirección memoria virtual
8 bits -> directorio 12 bits 12 bits -> desplazamiento
....... .......
comienzo tabla
1 pr pr w
.......
.......
22 bits -> dirección real
bit de presencia
directorio de tablas
Figura 8.6: Traducción paginada
que será más lenta. Se puede usar una TLB (Translation Lookaside
Buffer) , a modo de memoria caché, que contenga los pares (dirección
virtual, dirección fı́sica) más utilizados, acelerando ası́ el proceso.
b) El propio acceso a la tabla, dado que está paginada, puede producir un
fallo de página, con la penalización que eso lleva consigo.
SINOPSIS
Gran parte del rendimiento ofrecido por un computador recae en el buen di-
seño del sistema operativo que utilice. El sistema operativo, aunque software,
es fundamental en el uso de los elementos hardware que componen la máqui-
na. Sólo hay que fijarse un poco para observar que es un producto clave en
el mercado informático, tanto más cuando de él dependen recursos como la
conectividad en red que cada dı́a cobra más importancia. En este capı́tulo he-
mos esbozado las caracterı́sticas generales de un sistema operativo, incidiendo
en dos aspectos básicos: la gestión de procesos y la memoria virtual.
Apéndice A
Sistemas de representación
especiales
A.1. CÓDIGOS DETECTORES/CORRECTORES DE ERRO-

RES
La aparición de errores en el almacenamiento o transmisión de la información

ha dado lugar a la creación de códigos que permiten corregir o al menos detec-
tar los fallos que ocurren en el proceso de almacenamiento o transmisión. Dada
una secuencia binaria I que contiene la información, se procede a añadir una
secuencia redundante R deducida a partir de I que nos permitirá la detección
y/o corrección de los errores que se produzcan en I.
Se define la distancia Hamming entre dos palabras binarias, d(x,y), como
el número de bits en que difieren. Se entiende por distancia Hamming de un
código de palabras binarias, d(C), al min{d(x, y)/x, y ∈ C, x ̸= y}. El campo
redundante R se añade de forma que el código resultante formado por las
nuevas palabras (I,R) tenga una distancia mayor que el código formado por
las palabras I y por tanto permita distinguir si ha habido errores.
Se demuestra que el código con información redundante ha de tener una
distancia mı́nima de k + 1 si se quieren detectar k errores de un bit; y que
dicha distancia ha de ser 2k + 1 si lo que se quiere es poder corregir k errores
de un bit.
A.1.1. Bit de paridad

Es un mecanismo simple para la detección de un bit erróneo. Consiste en
añadir 1 bit de redundancia calculado de la siguiente forma:
209
Paridad par: El número total de 1’s en la palabra binaria resultante

(I,R) ha de ser par.
Paridad impar: El número total de 1’s en la palabra binaria resultante
(I,R) ha de ser impar.
A.1.2. Códigos polinómicos

El campo redundante R se calcula a partir del campo de información I y una
palabra de control C. Los bits redundantes se determinan como R = ImodC
expresando R con la misma longitud en bits que C. La facilidad del cálculo de
esta operación es un elemento a favor de estos códigos redundantes.
Estos códigos, tambien denominados de redundancia cı́clica (CRC), se sue-
len utilizar en transmisiones en las que errores en ráfagas de bits son frecuentes.
Como ejemplo, si I = 1010001100 y C = 1010 tendremos R = ImodC =
0010. Se suele expresar C como un polinomio con los coeficientes igual a los
dı́gitos binarios de C, en este ejemplo C ≡ x 3 + x.
A.1.3. Código Hamming

Con este código se pretende poder corregir y detectar errores de un bit. Se parte
de un campo de información I de n bits al que añadiremos p bits redundantes
para producir una palabra de n + p bits que es la que será transmitida. El
número de bits redundantes se determina como el menor entero sujeto a la
condición 2p ≥ n + p + 1. Veamos este código para el caso de n = 4.
Para n = 4, tenemos que el número de bits a añadir es p = 3. El campo de
información lo denotamos I = i4 i3 i2 i1 , y el campo redundante R = p3 p2 p1 . La
palabra de n + p bits resultante entremezcla los bits de I y R de la siguiente
manera: B = b7 b6 b5 b4 b3 b2 b1 = i4 i3 i2 p3 i1 p2 p1 . Aquı́ B es la palabra a transmitir
o enviar. Los bits redundantes se colocan en las posiciones potencia de dos de
B (b2k−1 = pk ).
Codificación: El bit redundante p i es calculado como la operación OR
exclusiva de los bits bk (1 ≤ k ≤ 7), que pertenezcan a I, cuyo subı́ndice k
expresado en binario contenga el bit i igual a 1. De esta forma:
p 1 = b3 ⊕ b5 ⊕ b7
p 2 = b3 ⊕ b6 ⊕ b7
p 3 = b5 ⊕ b6 ⊕ b7
APÉNDICE A. SISTEMAS DE REPRESENTACIÓN ESPECIALES 211
Decodificación: Recibida la palabra B = b 7 b6 b5 b4 b3 b2 b1 se determina la

palabra r3 r2 r1 donde cada ri se calcula como la operación OR exclusiva de los
bits bk (1 ≤ k ≤ 7) de B, cuyo subı́ndice k expresado en binario contenga el
bit i igual a 1; es decir se calculan como los p i pero teniendo en cuenta todos
los bits de B incluyendo los redundantes, y no sólo los de información. Ası́:
r1 = b1 ⊕ b3 ⊕ b5 ⊕ b7
r2 = b2 ⊕ b3 ⊕ b6 ⊕ b7
r3 = b 4 ⊕ b 5 ⊕ b 6 ⊕ b 7
La clave del código radica en los siguiente: Tal como hemos construido los
bits redundantes si existe un error en el bit b k se activarán aquellos ri que se
correspondan con los lugares donde k expresado en binario tiene 1’s. Es decir,
la palabra r3 r2 r1 considerada un número binario positivo indica el lugar en
B donde se ha producido el error, con lo cual no solo está detectado sino que
cómo sabemos qué bit es podemos corregirlo.
A.2. CÓDIGOS DE LONGITUD VARIABLE
Al construir un mensaje con sı́mbolos de un alfabeto podemos observar que no

todos los sı́mbolos del alfabeto aparecen con igual frecuencia (probabilidad).
De ahı́ surge la idea que será más eficiente una codificación que emplee menos
bits para representar los sı́mbolos más frecuentes. Esta es la idea que existe
detras de los códigos usados en la compresión de mensajes (por ejemplo los
compresores de ficheros).
A.2.1. Código Huffman

Un código representativo de este tipo de codificaciones de longitud variable es
el código Huffman.
La generación de este código sigue el siguiente esquema: Se parte de las
frecuencias relativas (probabilidades) de cada sı́mbolo del alfabeto. Los sı́mbo-
los se ordenan por probabilidades decrecientes. De forma sucesiva se colapsan
los dos sı́mbolos con probabilidades más bajas en un núevo sı́mbolo cuya pro-
babilidad es la suma de los sı́mbolos de los que proviene. El nuevo conjunto
resultante se vuelve a reordenar y se repite el proceso hasta que sólo queda
un sı́mbolo con probabilidad uno. Los sucesivos pasos se traducen en un árbol
binario que es usado para generar los códigos.
Ejemplo: Sea el alfabeto {1,2,3,4,5} con probabilidades asociadas {0.4,

0.2, 0.25, 0.1, 0.05}.
Reordenación: 1(0.4) 3(0.25) 2(0.2) 4(0.1) 5(0.05)
Agrupamiento: 1(0.4) 3(0.25) 2(0.2) A(0.15)
Agrupamiento: 1(0.4) 3(0.25) B(0.35)
Reordenación: 1(0.4) B(0.35) 3(0.25)
Agrupamiento: 1(0.4) C(0.6)
Reordenación: C(0.6) 1(0.4)
Agrupamiento: D(1)
El árbol resultante se muestra en la figura A.1. Hasta llegar a los nodos

sı́mbolos desde el raı́z, se va asignando un 1 a la rama derecha y un 0 a la
izquierda.
Con lo cual el código resultante es:
Sı́mbolo Código
1 0
3 10
2 110
4 1110
5 1111
D
1
0
C
1
0 B
1
0
0
A 1
1 3 2 4 5
Figura A.1: Arbol de generación Huffman

APÉNDICE A. SISTEMAS DE REPRESENTACIÓN ESPECIALES 213
A.3. EJERCICIOS
1. Elaborar los codigos Hamming para cada uno de los enteros naturales
en binario menores a 31.
2. Utilice el código Huffman para comprimir el siguiente mensaje en octal:
73567356713572252251052525252525252525255252555522237777615435. Cal-
cule la longitud media resultante y compárela con la que se necesitarı́a
si se usara binario natural.
3. Construya el diagrama de estados para un autómata de estados finitos
que sea capaz de reconocer el código Huffman creado para el ejercicio
anterior.
4. Usando el polinomio C = x15 + x12 + x5 + 1 calcule el campo CRC para
la secuencia binaria obtenida en 2.
5. Un procesador con arquitectura de ’cero direcciones (operandos)’ ejecuta
el programa:
1 push A 6 push B 11 pop R
2 push B 7 push C i
Pi
3 inc 8 push A Pi-1
4 add 9 add .......
5 pop A 10 mult
P0
Resumimos a continuación la acción de las instrucciones, número de
bytes en memoria que ocupan y duración del ciclo de instrucción (ck).
Denotaremos Pi el dato que se encuentra en la cima de la pila, siendo i
el puntero de pila. Cada vez que introducimos un nuevo dato en la pila
i se incrementa en 1.
Instrucción Acción N.o bytes ck
push X i ← i + 1 y después Pi ← X 3 75 ns.
pop X X ← Pi y después i ← i − 1 3 75 ns.
add Pi−1 ← Pi + Pi−1 y después i ← i − 1 1 75 ns.
mult Pi−1 ← Pi ∗ Pi−1 y después i ← i − 1 1 100 ns.
inc Pi ← Pi + 1, i no varı́a 1 75 ns.
a) Calcular el valor almacenado en R, en función de los valores iniciales

de las variables A = A0 , B = B0 y C = C0 , cuando finaliza la
ejecución del programa.
b) Sabiendo que todas las instrucciones del procesador tienen el mismo
tamaño de código de operación, ¿cuál es el tamaño de los operan-
dos?
c) Se desea diseñar un formato de código de operación variable basado

en la codificación Huffman, en el que las instrucciones que aparecen
con mayor frecuencia en un programa tengan menos bits en el código
de operación, permitiendo reducir el tamaño medio de los progra-
mas. Realizar el diseño completo de dicho código de operación para
el conjunto de instrucciones que se ha presentado sabiendo que el
código que se analiza representa bastante bien el comportamiento
general de los códigos escritos para este procesador.
Escribe los códigos de operación resultantes en la siguiente tabla:
Instrucción: push pop add mult inc
C.OP. Huffman:
Apéndice B
Rendimiento de un
computador
B.1. LEY DE AMDAHL
El término cuello de botella - del inglés bottleneck - se utiliza en la jerga del

rendimiento de computadores para referirse al subsistema o subsistemas que
degradan el rendimiento del equipo en general.
Puesto que todos los componentes de un computador están interconecta-
dos, un cambio en las prestaciones de un subsistema tiene un impacto inme-
diato en el rendimiento del sistema en general. Ahora bien, puestos a mejorar
algo, el sistema se beneficiará más si mejoramos el subsistema donde está loca-
lizado el cuello de botella y, de forma inversa, si queremos abaratar costes, lo
mejor es penalizar el subsistema con mejor rendimiento respecto a los demás.
Por otra parte, como no todos los componentes de un ordenador tienen
la misma frecuencia de uso en la ejecución de un programa, resultará más
beneficioso mejorar un subsistema cuanto más utilizado sea éste.
Como métrica del rendimiento en tiempos de un subsistema se emplea
la denominada aceleración o ganancia en tiempos, conocida por su término
anglosajón speed-up, definida como cociente el cociente de tiempos empleado
por el subsistema a evaluar y una referencia:
Tiempo consumido
α=
Tiempo de referencia
Para cuantificar el efecto en rendimiento global de un sistema a partir del

rendimiento de sus partes se utiliza la expresión conocida como ley de Am-
215
dahl, que establece que la mejora obtenida en el rendimiento de un sistema

debido a la alteración de uno de sus componentes está limitada por la frac-
ción de tiempo que se utiliza dicho componente. De forma analı́tica, esta ley
se resume en la siguiente fórmula:
1
α= p
(1 − p) + αm
cuyos parámetros poseen el siguiente significado:

α: Es la aceleración global del sistema completo tras la mejora de uno de
sus subsistemas. Si lo que se evalúa es un programa representa el cocien-
te entre el tiempo de ejecución completo del programa antes de mejorar
alguno de sus componentes y el tiempo de ejecución después de ser me-
jorado dicho componente.
αm : Representa el factor de mejora que se ha introducido en el subsistema
alterado, nos mide cómo de grande ha sido la mejora. Es la aceleración
parcial correspondiente al elemento mejorado considerado aisladamente.
p: Es la fracción de tiempo que el sistema completo original utiliza el sub-
sistema que se ha alterado (es decir, cuánto se usa el componente que se
ha mejorado en el sistema original).
Podemos generalizar la ley de Amdahl cuando se realiza la optimización
de más de una de las partes del sistema. Si n partes de un sistema consumen
fracciones del tiempo total (secuencial) p 1 , p2 , ... pn respectivamente y cada
una de ellas se optimiza individualmente con aceleraciones parciales α 1 , α2 , ...,
αn , quedando sin optimizar por tanto la fracción 1−(p 1 +p2 +...+pn ) del tiempo
secuencial original, la aceleración global sufrida por el tiempo consumido por
el sistema viene dado por:
1
α= 2 n
3 n
' ' pi
1− pi +
αi
i=1 i=1
Se deja al lector la deducción de la expresión de la ley de Amdahl, a partir
de la definición de los parámetros, ası́ como su generalización.
B.1.1. Ejemplo
Queremos mejorar el rendimiento de un computador introduciendo un copro-
cesador matemático que realice las operaciones aritméticas en la mitad de
tiempo. Calcular la ganancia en velocidad del sistema para la ejecución de
APÉNDICE B. RENDIMIENTO DE UN COMPUTADOR 217
un programa sabiendo que el 60 % de dicha ejecución se dedica al cálculo de

operaciones aritméticas. Si el programa tardaba 12 segundos en ejecutarse sin
la mejora, ¿ Cuánto tardará en ejecutarse sobre el sistema mejorado?
Solución:
Del enunciado tenemos que αm = 2 y p = 0.6. Aplicando la ley de Amdahl,
obtenemos:
1 1 1
α= 0.6 = 0.4 + 0.3 = 0.7 = 1.42
(1 − 0.6) + 2
Es decir, el sistema funciona un 42 % más rápido que el original.
Para responder a la segunda cuestión, expresamos α como el cociente entre
los tiempos de ejecución sin y con mejora, esto es:
Tiempo de ejecución sin mejora

α=
Tiempo de ejecución con mejora
Y dado que el numerador de esta expresión es 12 segundos, sustituyendo
A por 1.42 y despejando, obtenemos que el programa tardará 8.45 segundos
cuando se ejecute aprovechando el coprocesador matemático.
B.1.2. Casos lı́mite

De la fórmula de la ley de Amdahl podemos extraer unos cuantos casos par-
ticulares que merece la pena analizar ya que representan las limitaciones que
tenemos a la hora de ampliar el rendimiento global del sistema, al mejorar
únicamente una de sus partes.
1
1. Si αm = ∞, entonces α = 1−p : es decir, el porcentaje máximo que
un sistema puede acelerarse actuando sobre uno de sus componentes
está acotado en función de la fracción de uso de ese componente, como
puede apreciarse en la figura B.1 (a).
2. Si p = 0, entonces α = 1: la mejora de un componente, por grande que
sea, no tiene efecto alguno sobre el sistema global si no se utiliza dicho
componente, ver figura B.1 (b).
3. Si p = 1, entonces α = αm : esto es, si todo el tiempo de ejecución de un
programa se dedica a utilizar el subsistema mejorado, toda la ganancia
en velocidad que experimente dicho subsistema revierte sobre el sistema
general.
En definitiva, la ley de Amdahl representa una guı́a para conocer la mejor
forma de repartir el dinero a invertir en un sistema, por ejemplo un equipo
informático, entre los distintos componentes que lo integran en función de su
α
α
1 αm
1-p
1 1
αm p
1 0 1
(a) (b)
Figura B.1: Casos Lı́mite de la Ley de Amdahl.
uso, y de cuantificar el efecto que estos componentes tendrán sobre el sistema

en función de sus prestaciones.
B.2. OBSERVACIÓN DE MOORE
En 1965, Gordon Moore, cofundador de Intel, publicó un trabajo en el que

exponı́a que habı́a observado en los últimos años como el número de transis-
tores por (pulgada)2 de los circuitos integrados se habı́an duplicado cada año.
Moore además predijo que esta tendencia continuarı́a previsiblemente en el fu-
turo. En los años siguientes, la cosa se frenó un poco, pero la densidad de los
datos se duplicó aproximadamente cada 18 meses, lo que constituye la actual
definición de la Ley de Moore, que él mismo ha corroborado. La mayorı́a de
expertos, incluido el propio Moore, esperan que la ley de Moore se mantenga
por al menos otras dos décadas. En la figura B.2 se puede observar la ley de
Moore para los procesadores de Intel.
Existe una versión de la ley de Moore para discos duros. Según sus previsio-
nes, para el 2030 se llegarán a los 109 MBytes por pulgada cuadrada. Teniendo
en cuenta el crecimiento esperado del tamaño del software, será precisa esta
capacidad.
En relación con este aspecto, Nathan Myhrvold, un alto ejecutivo de Mi-
crosoft, formuló la conocida como primera ley del software, que establece que
el software es como un gas: se expande hasta llenar el continente donde se
encuentra (hardware).
100000
CPUs de Intel Pentium 4
2.5años
10000 Itanium
P6 (PentiumPro)
Miles de transistores
80486
P5 (Pentium)
1000
80386
80286
100
8086
10 Se duplica el número cada 2 años
4004
1
1975 1980 1985 1990 1995 2000 Año
Figura B.2: Observación de Moore para las CPUs de Intel
B.3. OBSERVACIÓN DE GROSCH
La observación Grosch viene a decir que la potencia de computación se incre-

menta como el cuadrado de el coste del computador ó P = KC 2 , donde P es
la potencia de cálculo, K es una constate y C es el coste del sistema. Es decir,
por el doble de dinero tenemos un ordenador 4 veces más potente.
La realidad nos dice que en el mercado de los PCs esto es solo una apro-
ximación. Sin embargo, la ley de Grosch nos da una buena idea cuál será el
precio de un PC más rápido en el futuro.
B.3.1. Ejemplo
Suponiendo que la potencia de computación de un PC se puede considerar
proporcional a su frecuencia de reloj, estimar cuál será el precio que tendrá el
Pentium a 2 GHz, teniendo en cuenta que un Pentium tı́pico a 500 MHz tiene
un precio de unas 1.000 euros.
Solución:
Aplicando la ley de Grosch, tenemos que el precio será:
4
2000
1.000 × = 1.000 × 2 = 2.000 euros
500
B.4. EJERCICIOS
1. Queremos analizar el rendimiento de un computador de 100 MHz. que

tiene instrucciones simples, normales y complejas, cada una con un CPI
distinto según se muestra en la tabla. Para ello, se utiliza un progra-
ma compilado en dos compiladores distintos que generan códigos objeto
con diferente número y tipo de instrucciones, (ver tabla). ¿ Qué versión
compilada del programa produce un mayor rendimiento atendiendo a los
MIPS? ¿Y atendiendo al tiempo de CPU?
Tipo de instrucción CPI Millones de instrucciones

Compilador 1 Compilador 2
Simple 1 5 10
Normal 2 1 1
Compleja 3 1 1
2. Considerar dos computadores, P1 y P2, con idéntico repertorio de ins-

trucciones (A, B, C, D). P1 funciona a 50 MHz y con CPIs 1, 2, 3 y 4
para A, B, C y D, respectivamente. P2, por el contrario, funciona a 75
MHz. pero con CPIs respectivos de 3, 5, 5 y 7. Si ejecutamos en ambos
un mismo programa compuesto por igual número de instrucciones de
cada tipo, ¿Cuál de ellos mostrará un mayor rendimiento en MIPS?
3. MeEscapé, una empresa dedicada al software de Internet, usa, para sus
operaciones matemáticas, rutinas compradas a otra compañı́a. Estas fun-
ciones suponen el 10 % del tiempo de ejecución del código, y son el doble
de rápidas de las que inicialmente usaban en la primera versión de sus
productos.
Por una polı́tica de ahorro, se decide cambiar a las funciones que
ofrece una nueva empresa, que aunque son algo más lentas, también son
más baratas. Esta decisión se debe a que se ha observado que haciendo
un cambio en la estructura de los programas, se consigue que, aunque las
nuevas llamadas sean un 25 % más lentas (que las que iban el doble de
rápidas), el código, de forma global, siga comportándose de igual modo
a como lo hacı́a antes en cuanto a velocidad de ejecución.
a) ¿ Cuál ha sido ese cambio? ¿ En qué se basa ese comportamiento,
en principio extraño, del programa? Justifı́quese la respuesta.
b) Cuantificar el cambio necesario en el programa, como mı́nimo, para
que se puedan usar las nuevas funciones.
4. El nuevo procesador de la compañı́a Acme Microsys se encuentra ac-

tualmente en fase de desarrollo. Los únicos datos que se conocen son
relativos un programa multimedia de prueba, el cual tarda 15 segundos
en ejecutarse, con un CPI medio de 3, y en el que cada tipo de instrucción
gráfica necesita una media de 4 ciclos de reloj para ejecutarse utilizando
la tarjeta de video T1. Una prueba posterior del mismo programa sobre
otra tarjeta (T2) redujo a la mitad los ciclos empleados por cada tipo
de instrucción gráfica, lo que implicó una reducción de 5 segundos en el
tiempo de ejecución de la prueba.
a) Calcular el CPI medio de la segunda prueba.
b) Sabiendo que la prueba tiene un total de 5000 instrucciones, calcula
el número de instrucciones gráficas contenidas en dicho programa.
c) Con la nueva tarjeta de vı́deo T3, el CPI de la prueba pasó a ser 1.8.
Obtener el número de ciclos medio que debe tardar cada instrucción
gráfica con la nueva tarjeta T3.
5. Un computador ejecuta un programa en 100 segundos, siendo las opera-
ciones de multiplicación responsables del 80 % de ese tiempo. ¿ Cuánto
habrı́a que mejorar la velocidad de la multiplicación si se desea que el
programa se ejecute 5 veces más rápido? Solución: No hay forma de con-
seguir una mejora de tal magnitud para ese programa acelerando sólo la
multiplicación.
6. Un programa que dedica la mitad de su tiempo a cálculos en punto flo-
tante se ejecuta sobre un computador en 10 segundos. Si cambiamos su
FPU por otra 5 veces más rápida, ¿Qué ganancia en velocidad experi-
mentará el programa? Solución: A = 1.6
7. Queremos reducir el tiempo de ejecución de un programa en un compu-
tador incorporándole una memoria caché para almacenar instrucciones.
Cuando el procesador encuentra una instrucción en la caché, ésta se eje-
cuta 10 veces más rápido que cuando debe acceder a memoria principal.
Indicar el porcentaje mı́nimo de instrucciones que se deben encontrar
en caché para conseguir ejecutar el programa en menos de la mitad de
tiempo. Solución: 55 %
8. Una forma de mejorar el rendimiento de un computador es utilizando
un sistema multiprocesador. Generalmente, sólo una parte del progra-
ma a ejecutar puede paralelizarse, esto es, admite una descomposición
en tareas que permita beneficiarse de la existencia de múltiples CPUs.
Si queremos medir el rendimiento de una máquina de N procesadores
a través de un benchmark que tarda 100 segundos en una máquina se-
cuencial y donde el 90 % de sus tareas son paralelizables, se pide:

a) La aceleración que experimentará el benchmark en este sistema en
función del número de procesadores (N).
b) Si pudiésemos incrementar el número de procesadores de forma in-
definida, ¿ Estarı́an acotados de alguna manera la aceleración y el
tiempo de ejecución para esta máquina?
100
Solución: a = 10+ 90 . Por mucho que aumentemos N, la aceleración
N
se encuentra acotada superiormente en un valor 10 y el tiempo de eje-
cución inferiormente en 10 segundos.
9. Se desea mejorar el rendimiento de un PC. Para ello tenemos dos opcio-
nes:
a) Ampliar la memoria RAM, con lo que se consigue que el 80 % de
los programas vayan 1.75 veces más rápido.
b) Introducir un disco duro mayor, con lo que el 60 % de los programas
realizan su tarea en la tercera parte del tiempo original.
A igualdad de precio, ¿ Cuál de las dos mejoras aconsejarı́as ? Solu-
ción: La primera alternativa produce una aceleración de 1.52, mientras
que la segunda 1.66. Nos quedamos pues con la mejora del disco duro.
Apéndice C
Códigos completos para el

i8086
C.1. CÓDIGOS COMPLETOS
Los siguientes códigos corresponden con algunos de los problemas del capı́tulo
3. En este apéndice los códigos se muestran de forma completa, incluyendo los
segmentos de datos, pila y código para poder ser ensamblados.
memoria. Escribir un programa en ensamblador que cuente los números
P ≥ 0 y N < 0 y que almacene P en la posición 1000 de memoria y N
en la 1002.
;----------------
DATOS SEGMENT
; aqui declarar variables si hace falta
DATOS ENDS
;----------------
PILA SEGMENT
DB 512 DUP(0)
PILA ENDS
;----------------
CODIGO SEGMENT
INICIO:MOV CX, 0H ; contador de positivos o cero
MOV DX, 0H ; contador de negativos
MOV DS, 0H ; los datos el el segmento 0
MOV SI, 500 ; inicializar desplazamiento
;----------------
223
LAZO: CMP SI, 998 ; hemos llegado al final?

JG FIN
CMP WORD PTR [SI],0H ; Direcionamos DS:SI como palabra
JLE NEGA
ADD CX,1
ADD SI,2 ; SI apunta a la siguiente palabra
JMP LAZO
NEGA: ADD DX,1
JMP LAZO
;ahora SI=1000
FIN: MOV [SI], CX
MOV [SI+2], DX
;----------------
FINP:MOV AH,4CH ; interrupcion fin de programa
INT 21H
CODIGO ENDS
;----------------
END INICIO
2. Tenemos 100 números positivos de 16 bits en las posiciones de memoria

1000 a 1198. Escribir un programa que determine cuál es el número
mayor de todos y lo almacene en la posición 1200.
;----------------
DATOS SEGMENT AT 1200 ; variable que contiene el mayor en 1200
MAYOR DW 0
DATOS ENDS
;----------------
PILA SEGMENT STACK
DB 512 DUP(0)
PILA ENDS
;----------------
CODIGO SEGMENT
INICIO:MOV ES, 0H ; los datos el el segmento 0
MOV SI, 1000; inicializar desplazamiento
MOV AX, SEG DATOS
MOV DS, AX ; iniciar DS apuntando a datos
;----------------
LAZO: CMP SI, 1198; hemos llegado al final?
JG FIN
CMP WORD PTR ES:[SI], WORD PTR MAYOR
JLE MENOR
MOV MAYOR, WORD PTR ES:[SI]
MENOR:
APÉNDICE C. CÓDIGOS COMPLETOS PARA EL 8086 225

JMP LAZO
;----------------
FIN: MOV AH,4CH ; interrupcion fin de programa
INT 21H
CODIGO ENDS
;----------------
END INICIO
3. Escribir un procedimiento en lenguaje ensamblador para calcular el su-

matorio de los números naturales desde 1 hasta N. Supongamos que
N está almacenado en la posicion fisica 500 y queremos almacenar el
sumatorio en la posición 502.
;----------------
DATOS SEGMENT AT 500
NUMERO DW 6
SUMAT DW ?
DATOS ENDS
;----------------
PILA SEGMENT STACK
DB 512 DUP(0)
PILA ENDS
;----------------
CODIGO SEGMENT
MOV AX, SEG DATOS
MOV DS, AX ; DS apuntando a datos
;----------------
INICIO: MOV AX, NUMERO; guardo el numero en AX
MOV CX, 0 ; inicio CX donde metere el sumatorio
LAZO: ADD CX,AX
SUB AX,1
CMP AX,0
JNE LAZO
FIN: MOV SUMAT, CX
;----------------
INT 21H
CODIGO ENDS
;----------------
END INICIO
4. Escribe el diagrama de flujo y el programa en ensamblador del para el

algoritmo que realiza la siguiente función: Dada una tabla en la posi-
ción 100 de memoria con 50 números de 16 bits en complemento a dos,

multiplicar por 2 los números pares y dividir por 2 los impares (divi-
sión entera), dejando cada número modificado en la misma posición de
la tabla en la que estaba. No utilizar las instrucciones de multiplica-
ción y división (MULS y DIVS). No considerar el caso de overflow al
multiplicar por dos.
;----------------
TABLA DW 50 DUP(?) ; zona de memoria con los numeros
DATOS ENDS
;----------------
PILA SEGMENT STACK
DB 512 DUP(0)
PILA ENDS
;----------------
CODIGO SEGMENT
MOV AX, SEG DATOS
MOV DS, AX ;cargar DS con el seg de datos
LEA SI, TABLA ;SI apuntando a TABLA
;----------------
MOV DX,50 ;contador de elementos de la tabla
LAZO: MOV AX, [SI]
MOV BX, AX
AND BX, 01H
CMP BX, 01H
JE IMPAR
SAL AX, 01H
JMP SEGUIR
IMPAR: SAR AX, 01H
SEGUIR:MOV [SI], AX
ADD SI, 2 ; SI apunta a la siguiente palabra
SUB DX, 1 ; decremento contador del bucle
CMP DX, 0
JNE LAZO
;----------------
INT 21H
CODIGO ENDS
;----------------
END INICIO
5. Escribe el diagrama de flujo y el programa en ensamblador para el al-

goritmo que realiza la siguiente función: Dada una tabla en la posición
APÉNDICE C. CÓDIGOS COMPLETOS PARA EL 8086 227
500 de memoria con 50 números de 16 bits en complemento a dos, for-

zar a cero los números negativos y multiplicar por tres los positivos,
dejando cada número modificado en la misma posición de la tabla en
la que estaba. No utilizar ninguna instrucción de multiplicar (MULS).
No considerar el caso de overflow al multiplicar por tres. (Observar que
multiplicar por 3 es sumar a un numero su doble).
;----------------
TABLA DW 50 DUP(?) ; zona de memoria con los numeros
DATOS ENDS
;----------------
PILA SEGMENT STACK
DB 512 DUP(0)
PILA ENDS
;----------------
CODIGO SEGMENT
MOV AX, SEG DATOS
MOV DS, AX ;cargar DS con el seg de datos
LEA SI, TABLA ;SI apuntando a TABLA
;----------------
MOV DX,50
LAZO: MOV AX, [SI]
CMP AX, 00H
JE NEGA
SAL AX, 01H
ADD [SI], AX
JMP SEGUIR
NEGA: MOV [SI], 0H
SEGUIR:ADD SI, 2 ;apuntar a la siguiente palabra
SUB DX, 1
CMP DX, 0
JNE LAZO
;----------------
INT 21H
CODIGO ENDS
;----------------
END INICIO
Apéndice D
Detalles de diseño de cache
D.1. POLÍTICAS DE ASIGNACIÓN
Veamos en más detalle como se mapean los datos de la memoria principal en

la memoria caché. Vamos a considerar una memoria principal de 2 N lı́neas,
una memoria caché de 2n lı́neas de capacidad y 2w palabras por lı́nea.
D.1.1. Asignación directa

Con este criterio, la correspondencia entre memoria principal y caché se hace
de la siguiente manera: la lı́nea i de la memoria principal se ubica en la lı́nea
i mod 2n de la caché. Ası́, los subconjuntos de lı́neas de memoria principal que
pueden ser almacenadas en cada lı́nea caché son disjuntos.
Partiendo de la dirección de palabra de memoria principal, es fácil ubicar
la lı́nea correspondiente en memoria: los últimos w bits indican qué palabra re-
ferenciamos dentro de la lı́nea, los n siguientes indican qué linea referenciamos
dentro de la caché y el resto (los más significativos) nos sirven para determinar
si la lı́nea está en caché o no (etiqueta) (ver figura D.1).
Entre las ventajas de este tipo de asignación encontramos su simplicidad
y su bajo coste: sólo hace falta el uso de un comparador para saber si la
lı́nea está en la caché, el directorio caché es una memoria convencional (no
asociativa) y no hace falta algoritmo de reemplazo (cada lı́nea de memoria
principal se mapea de forma unı́voca en la caché).
Como inconveniente se encuentra el hecho de que la caché puede tener
lı́neas vacı́as y sin embargo, ocurra reemplazo (cuando los accesos consecutivos
a memoria principal están a una distancia 2 n lı́neas).
229
N+w bits (dirección de palabra de memoria)
MEM principal etiqueta línea de cache palabra
n w
línea memoria principal
CACHE
linea k
.....
.....
etiqueta ....... pal. w ....... linea k
.....
.....
.....
linea k+2**n
directorio
Figura D.1: Asignación directa
D.1.2. Asignación completamente asociativa

Para paliar el inconveniente anterior, una organización totalmente asociativa
va a permitir que cualquier lı́nea de memoria principal pueda ubicarse en
cualquier lı́nea de la caché. Para ello, partiendo de la dirección de la palabra
referenciada, los N bits más significativos indican a qué lı́nea pertenece la
palabra en memoria principal. Por tanto, guardando esta información en el
directorio, y realizando una búsqueda asociativa en él, determinamos si se
encuentra o no la lı́nea en caché y, en caso de que se encuentre, cuál es su
posición en la caché (ver figura D.2).
Vemos que este criterio maximiza la flexibilidad y el rendimiento al poder
ser ocupada cualquier posición libre de la caché. Como contrapartida el coste
aumenta: se necesita una memoria asociativa y además es necesario implemen-
tar un algoritmo de reemplazo.
D.1.3. Asignación asociativa por conjuntos

Es una organización de compromiso entre las dos anteriores. La caché se orga-
niza en 2c unidades que denominaremos conjuntos, cada uno de los cuales va a
APÉNDICE A. DETALLES DE DISEÑO DE CACHE 231
MEM principal etiqueta palabra
N w
......
CACHE
......
......
......
etiqueta ....... pal. w .......
......
......
......
......
directorio
......
Figura D.2: Asignación completamente asociativa
contener 2n−c lı́neas. Al número de lı́neas por conjunto le denominaremos ni-

vel de asociatividad. Lo que se pretende hacer es que la selección del conjunto
se realice con mapeo directo y, una vez seleccionado el conjunto, la ubicación
dentro de éste sea asociativa.
Para ello, la lı́nea de memoria principal i será cargada en caché en el con-
junto i mod 2c y, dentro de ese conjunto, podrá ocupar cualquier lı́nea caché.
Ası́, una dirección de palabra de la memoria principal la dividiremos en tres
campos: los w bits menos significativos indican como antes qué palabra refe-
renciamos dentro de la lı́nea, los c bits siguientes seleccionan a qué conjunto
de caché va destinada y los N − c bits más significativos constituyen la eti-
queta a guardar para la búsqueda asociativa dentro del conjunto que le haya
correspondido (ver figura D.3). Observemos que cuando un conjunto está lleno
hay que aplicar alguna polı́tica de reemplazo para sustituir las lı́neas dentro
de ese conjunto.
Observemos que cuando c = 0, es decir, sólo hay un conjunto, la organi-
zación equivale a una totalmente asociativa, y que cuando c = n, es decir,
2n conjuntos (nivel de asociatividad = 1), la organización equivale a la de
asignación directa.
n bits línea cache
N bits línea memoria principal
etiqueta conjunto palabra
N-c c w
MEM principal
conjunto 0 CACHE
linea 0 ..... .....
etiqueta ....... pal. w .......

......
..... .....
linea 2**c
conjunto 1
......
linea 2*2**c
......
......
......
linea 3*2**c conjunto c-1
......
directorio
Figura D.3: Asignación asociativa por conjuntos
D.2. REEMPLAZO Y ACTUALIZACIÓN
Como ya se ha esbozado en párrafos anteriores, en las organizaciones con más

de una lı́nea por conjunto, es necesario introducir una polı́tica de reemplazo
de aquellas lı́neas que son referenciadas en memoria principal y que pueden
ser ubicadas en diferentes posiciones dentro de la caché. Los algoritmos de
reemplazo se diseñan con el objetivo de disminuir la tasa de fallos, minimizando
el tráfico entre memoria principal y caché. Estos algoritmos, además, deben
estar implementados en hardware para no degradar la velocidad de respuesta
del sistema.
Los tres algoritmos más usados son:
1. LRU (Least Recently Used): Se elimina aquella lı́nea que hace máss tiem-
po que no se usa (lectura o escritura).
2. FIFO (First In First Out): Se elimina aquella lı́nea que entró en la
caché hace más tiempo.
3. RANDOM: Se escoge la lı́nea a eliminar aleatoriamente.

El menos complejo de implementar es el último, pero sus resultados son
peores, ya que no utiliza ninguna información relacionada con la localidad. FI-
FO se puede implementar simplemente asociando a cada conjunto un contador
módulo el nivel de asociatividad, que apuntarı́a a la siguiente lı́nea a sustituir.
LRU es más complejo de implementar (hay que medir de alguna forma cuánto
lleva la lı́nea en caché), aunque también es el que presenta mejores resultados.
Con Algoritmo de Carga hacemos referencia a la manera de decidir
qué información se carga en la caché y cuándo. Lo más simple es realizar la
carga bajo demanda, esto es, cargar en caché aquella lı́nea de memoria principal
a la que pertenece la palabra de memoria referenciada. Otra posibilidad serı́a
usar un algoritmo de precarga, en el que no sólo cargaremos en caché la lı́nea
referenciada, sino otras próximas a ésta (por ejemplo algunas consecutivas).
En este caso, son diferentes los factores a tener en cuenta: cuántas y cuáles
lı́neas son las que vamos a precargar, cuándo se realiza la precarga (siempre,
bajo fallo, ...), etc.
La información de la memoria principal debe ser coherente con la que se
encuentra en la caché. Esta información se modifica cuando se efectúa una
escritura en la memoria. Encontramos dos polı́ticas básicas de actualización
de memoria:
1. Escritura directa o Write-through: Cada vez que se actualiza (escribe)
una posición en la caché es actualizada su posición correspondiente en
la memoria principal. Con esto garantizamos una buena consistencia de
los datos, mientras que, por otra parte, el tráfico entre caché y memoria
principal aumenta.
2. Post-escritura o Write-back: Los datos se escriben en la caché y el nue-
vo dato no pasa a memoria principal hasta cierto tiempo después (por
ejemplo, cuando la lı́nea modificada es eliminada de la caché). En este
caso, habrá que añadir un bit al directorio indicando que la lı́nea ha sido
modificada. El tráfico se reduce, pero la consistencia de datos podrı́a
dar problemas en caso de sistemas multiprocesadores o DMA (Direct
Memory Access).
Otro factor de diseño es el empleo de cachés separadas, una para las
referencias a datos y otra para las referencias a instrucciones. Con ello con-
seguimos aumentar el ancho de banda, ya que se pueden acceder a las dos
simultáneamente (por ejemplo, con un procesador segmentado) y disminuir el
tiempo de acceso si fı́sicamente situamos la caché de datos cerca de la sección
de procesamiento y la de instrucciones cerca de la lógica de decodificación.
Por último, apuntar que es posible interponer varios niveles de caché en-
tre la memoria principal y el microprocesador. Cada caché tratarı́a la de nivel
superior como si fuera su memoria principal, funcionando tal como hemos vis-
to, siendo cada nivel más rápido y de menor capacidad cuanto más cerca se
encuentre del microprocesador.
D.3. RENDIMIENTO DE MEMORIAS CACHÉS
El rendimiento de un sistema caché vendrá dado por la relación existente entre

los fallos y aciertos y la latencia de los diferentes elementos que componen el
sistema.
Para una traza dada la relación entre fallos, aciertos y precarga se suele
medir mediante los siguientes parámetros:
o fallos
Índice o tasa de fallos: Es el cociente Pmiss = N.oN.referencias y representa la
probabilidad de que una petición genere un fallo de caché.
o aciertos
Índice o tasa de aciertos: Es el cociente P success = N.N.o referencias y repre-
senta la probabilidad de que una petición genere un éxito de caché. Se
tendrá que Psuccess + Pmiss = 1.
N.o precargas
Índice o tasa de precarga: Es el cociente P pref etch = N. o referencias y repre-
senta la probabilidad de que una petición genere una precarga.
A continuación, a modo de ejemplo, se evalúa el rendimiento de diferen-
tes topologı́as determinando el tiempo de acceso equivalente del sistema de
memoria.
Topologı́a caché de un solo nivel unificada sin precarga. Usaremos un
modelo caracterizado por los siguientes parámetros: t c tiempo de laten-
cia de la caché, Trmc tiempo de transferencia o transporte de memoria
principal a caché.
El tiempo medio consumido nos proporciona la latencia efectiva del
sistema completo y viene dado por la expresión:
T = Tsuccess + Tmiss = (1 − Pmiss )tc + Pmiss (tc + Trmc )
Si consideramos que el tiempo de acceso a memoria principal sin caché es

aproximadamente Trmc , el speed-up obtenido gracias al sistema caché vendrá da-
do por:
Tno cache Trmc

α= =
Tcache (1 − Pmiss )tc + Pmiss (tc + Trmc )
Topologı́a caché de un solo nivel unificada con precarga. Usando el mis-

mo modelo de antes, y considerando t p la penalización introducida por
cada precarga, basta sumar el tiempo adicional que representan éstas,
para calcular la latencia equivalente:
T = Tsuccess + Tmiss + Tpref etch = (1 − Pmiss )tc +

Pmiss (tc + Trmc ) + Ppref etch tp
La precarga será beneficiosa si este tiempo es menor al que se obtendrı́a

en caso de que la precarga no estruviera presente. Observemos que el
ı́ndice de fallos y aciertos se modifica al introducir un algoritmo de pre-
carga y que en condiciones de localidad favorables es de esperar que el
aumento del ı́ndice de aciertos compense la penalización de las lı́neas
precargadas.
Topologı́a caché unificada de dos niveles sin precarga. Denominando t c1
el tiempo de latencia de la caché de primer nivel (L1), t c2 el tiempo de
transporte de los datos desde el primer (L1) al segundo nivel (L2) y T rmc
tiempo de transferencia o transporte de memoria principal al segundo
nivel y considerando una tasa de fallos en el primer nivel de P miss1 y una
tasa de fallos en el segundo nivel de Pmiss2 , la latencia efectiva, viene
dada para este caso por:
T = Tsuccess + Tmiss L1 + Tmiss L2 = (1 − Pmiss1 )tc1 +

Pmiss1 (1 − Pmiss2 )(tc1 + tc2 ) + Pmiss1 Pmiss2 (tc1 + tc2 + Trmc )
Topologı́a caché separada Datos+Instrucciones. El rendimiento se de-

termina de forma análoga al caso unificado, sólo que considerando se-
paradamente, en la traza de peticiones, lo que son peticiones de datos
y peticiones de instrucciones. Si Tdata es la latencia equivalente en la
caché de datos, Ti’s la de la caché de instrucciones, Pdata la probabili-
dad de petición de datos en la traza completa y P i’s la probabilidad de
petición de instrucciones, la latencia efectiva se determinará como:
T = Pdata Tdata + Pi’s Ti’s

D.4. EJERCICIOS
1. Dado un sistema de memoria principal de 1 Mb. y un programa que

referencia a la siguiente secuencia de direcciones (en hexadecimal):
ABC80h, ABC81h, ABC88h, BCD90h, BCD9Dh, BCDA0h,
CDE00h, CDE18h, CDE20h
Considerar las dos estrategias que se detallan a continuación para
acelerar el acceso a memoria principal:
I) Entrelazar la memoria principal siguiendo un esquema de orden
inferior con 32 módulos y latches a la salida.
II) Incorporar una memoria caché de 64 Kb. organizada asociativa-
mente en 4 conjuntos, 8 palabras por linea, sin precarga y algoritmo
de reemplazo FIFO.
Se pide:
a) Analizar y comparar el tiempo total de respuesta (en ciclos de CPU)
de esos dos sistemas de memoria para la secuencia de direcciones
solicitada por el programa. Considerar un tiempo de acceso de 10
ciclos de CPU para la memoria principal y de un solo ciclo para la
caché y los latches de la memoria entrelazada. Suponer la caché ini-
cialmente vacı́a e ilustrar claramente el contenido de los latches y
del directorio caché tras cada acceso a memoria principal.
b) Discutir posibles mejoras en ambos sistemas y su repercusión en
el coste: En el entrelazado, respecto al número de módulos y la
colocación de los latches; en la caché, respecto a su organización y
a los algoritmos para precarga y reemplazo de lı́neas.
Solución:
Como el factor de entrelazamiento es 32, los últimos 5 bits deter-
minan el módulo en el que se encuentra una referencia. Ası́ si se hace
referencia a una posición A, se lee a la vez desde la posición (A div 32)∗32
hasta (A div 32) ∗ 32 + 31, siendo div la división entera. (La dirección se-
leccionada en el módulo 0 se obtiene poniendo los últimos 5 bits de A a
0, y la dirección en el módulo 31 poniendo los últimos 5 bits a 1).
referencia palabra en latches? tiempo
ABC80h -> NO. Cargar ABC80...ABC9F 10+1 ciclos
ABC81h -> SI. 1 ciclo
ABC88h -> SI. 1 ciclo
BCD90h -> NO. Cargar BCD80...BCD9F 10+1 ciclos
BCD9Dh -> SI 1 ciclo
BCDA0h -> NO. Cargar BCDA0...BCDBF 10+1 ciclos
CDE00h -> NO. Cargar CDE00...CDE1F 10+1 ciclos
CDE18h -> SI 1 ciclo
CDE20h -> NO. Cargar CDE20...CDE3F 10+1 ciclos
El sistema de caché propuesto evoluciona de la siguiente manera:
Parametros: Cto. Lin. Etq. Ref.

Memoria principal = 1Mpalabras->N+w=20 0x0 0x0 0x55e4 1
Memoria caché = 8Klineas ->n=13 0x0 0x1 0x5e6d 5
Palabras por lı́nea = 8 ->w=3 0x1 0x0 0x55e4 2
Numero de conjuntos= 4 ->c=2 0x2 0x0 0x5e6c 3
0x3 0x0 0x5e6c 4
Lineas en cache:8192, Conjuntos:4, Ref. 0xcde00, etiqueta=0x66f0,
Lineas por conjunto:2048, c=0x0, w=0x0
Reemplazo:FIFO Precarga:NO ----Linea vacia: conjunto:0x0,
linea en conj.:0x2
Ref. 0xabc80, etiqueta=0x55e4, ----Directorio:
c=0x0, w=0x0 Cto. Lin. Etq. Ref.
----Linea vacia: conjunto:0x0, 0x0 0x0 0x55e4 1
linea en conj.:0x0 0x0 0x1 0x5e6d 5
----Directorio: 0x0 0x2 0x66f0 6
Cto. Lin. Etq. Ref. 0x1 0x0 0x55e4 2
0x0 0x0 0x55e4 0 0x2 0x0 0x5e6c 3
Ref. 0xabc81, etiqueta=0x55e4, 0x3 0x0 0x5e6c 4
c=0x0, w=0x1 Ref. 0xcde18, etiqueta=0x66f0,
----Exito c=0x3, w=0x0
----Directorio: ----Linea vacia: conjunto:0x3,
Cto. Lin. Etq. Ref. linea en conj.:0x1
0x0 0x0 0x55e4 1 ----Directorio:
Ref. 0xabc88, etiqueta=0x55e4, Cto. Lin. Etq. Ref.
c=0x1, w=0x0 0x0 0x0 0x55e4 1
----Linea vacia: conjunto:0x1, 0x0 0x1 0x5e6d 5
linea en conj.:0x0 0x0 0x2 0x66f0 6
----Directorio: 0x1 0x0 0x55e4 2
Cto. Lin. Etq. Ref. 0x2 0x0 0x5e6c 3
0x0 0x0 0x55e4 1 0x3 0x0 0x5e6c 4
0x1 0x0 0x55e4 2 0x3 0x1 0x66f0 7
Ref. 0xbcd90, etiqueta=0x5e6c, Ref. 0xcde20, etiqueta=0x66f1,
c=0x2, w=0x0 c=0x0, w=0x0
----Linea vacia: conjunto:0x2, ----Linea vacia: conjunto:0x0,
linea en conj.:0x0 linea en conj.:0x3
----Directorio: ----Directorio:
Cto. Lin. Etq. Ref. Cto. Lin. Etq. Ref.
0x0 0x0 0x55e4 1 0x0 0x0 0x55e4 1
0x1 0x0 0x55e4 2 0x0 0x1 0x5e6d 5
0x2 0x0 0x5e6c 3 0x0 0x2 0x66f0 6
Ref. 0xbcd9d, etiqueta=0x5e6c, 0x0 0x3 0x66f1 8
c=0x3, w=0x5 0x1 0x0 0x55e4 2
----Linea vacia: conjunto:0x3, 0x2 0x0 0x5e6c 3
linea en conj.:0x0 0x3 0x0 0x5e6c 4
----Directorio: 0x3 0x1 0x66f0 7
Cto. Lin. Etq. Ref.
0x0 0x0 0x55e4 1 Estadisticas:
0x1 0x0 0x55e4 2 Referencias: 9
0x2 0x0 0x5e6c 3 Lineas precargadas: 0
0x3 0x0 0x5e6c 4 Exitos en referencias: 1
Ref. 0xbcda0, etiqueta=0x5e6d, Exitos incluyendo precargaas: 1
c=0x0, w=0x0
----Linea vacia: conjunto:0x0, Tiempo=num_fallos*(10+1ciclos)
linea en conj.:0x1 +num_aciertos*1ciclo
----Directorio:
2. Considerar una memoria principal de 1 Mb. estructurada en palabras de

1 byte y a la que se dota de una memoria caché de 64 Kb., lı́neas de
4096 palabras, sin precarga y algoritmo de reemplazo FIFO.
Sea la secuencia de acceso a memoria principal dada por las siguientes
direcciones:
00000h, 01000h, 01001h, 0F000h, 10000h, 00000h,
40000h, 20000h, 080000h
Para una organización directa, totalmente asociativa, y asociativa de

4 conjuntos, se pide:
a) Mostrar la evolución de la caché y su directorio en cada caso, indi-
cando los fallos y precargas que se producen.
b) Calcular el coste de cada implementación con respecto al número
de bits del directorio caché y al número y tamaño de las memorias
asociativas que lo componen.
c) Ordenar las tres alternativas en base a criterios de rendimiento y
coste.
Solución:
*ASIGNACION DIRECTA: Lin. Etq. Ref.

Param.: n= 4, c= 4, w=12 0x0 0x1 4
Cache de mapeo directo 0x1 0x0 2
Lineas en cache: 16 0xf 0x0 3
Palabras por linea: 4096 Ref. 0x0, etiqueta=0x0,
Conjuntos: 16 c=0x0, w=0x0
Lineas por conjunto: 1 ----Reemplazo: linea:0x0
No precarga ----Directorio:
Lin. Etq. Ref.
Ref. 0x0, etiqueta=0x0, 0x0 0x0 5
c=0x0, w=0x0 0x1 0x0 2
----Linea vacia: conjunto:0x0, 0xf 0x0 3
linea en conj.:0x0 Ref. 0x40000, etiqueta=0x4,
----Directorio: c=0x0, w=0x0
Lin. Etq. Ref. ----Reemplazo: linea:0x0
0x0 0x0 0 ----Directorio:
Ref. 0x1000, etiqueta=0x0, Lin. Etq. Ref.
c=0x1, w=0x0 0x0 0x4 6
----Linea vacia: conjunto:0x1, 0x1 0x0 2
linea en conj.:0x0 0xf 0x0 3
----Directorio: Ref. 0x20000, etiqueta=0x2,
Lin. Etq. Ref. c=0x0, w=0x0
0x0 0x0 0 ----Reemplazo: linea:0x0
c=0x1, w=0x1 0x0 0x2 7
----Exito 0x1 0x0 2
----Directorio: 0xf 0x0 3
Lin. Etq. Ref. Ref. 0x80000, etiqueta=0x8,
0x0 0x0 0 c=0x0, w=0x0
0x1 0x0 2 ----Reemplazo: linea:0x0
Ref. 0xf000, etiqueta=0x0, ----Directorio:
c=0xf, w=0x0 Lin. Etq. Ref.
----Linea vacia: conjunto:0xf, 0x0 0x8 8
linea en conj.:0x0 0x1 0x0 2
----Directorio: 0xf 0x0 3
Lin. Etq. Ref. Estadisticas:
0x0 0x0 0 Referencias: 9
0x1 0x0 2 Lineas precargadas: 0
0xf 0x0 3 Exitos en referencias: 1
Ref. 0x10000, etiqueta=0x1, Exitos incluyendo lineas precargadas: 1
c=0x0, w=0x0 Fallos incluyendo lineas precargadas: 8
----Reemplazo: linea:0x0 Fallos compulsorios total: 3
----Directorio:
*COMPLETAMENTE ASOCIATIVA: Reemplazo: FIFO

Param.: n= 4, c= 0, w=12 No precarga.
Lineas en cache: 16
Palabras por linea: 4096 Ref. 0x0, etiqueta=0x0, w=0x0
Conjuntos: 1 ----Linea vacia: conjunto:0x0,
Lineas por conjunto: 16 linea en conj.:0x0
----Directorio: Ref. 0x40000, etiqueta=0x40, w=0x0

Lin. Etq. Ref. ----Linea vacia: conjunto:0x0,
0x0 0x0 0 linea en conj.:0x4
Ref. 0x1000, etiqueta=0x1, w=0x0 ----Directorio:
----Linea vacia: conjunto:0x0, Lin. Etq. Ref.
----Directorio: 0x1 0x1 2
Lin. Etq. Ref. 0x2 0xf 3
0x0 0x0 0 0x3 0x10 4
0x1 0x1 1 0x4 0x40 6
Ref. 0x1001, etiqueta=0x1, w=0x1 Ref. 0x20000, etiqueta=0x20, w=0x0
----Exito ----Linea vacia: conjunto:0x0,
----Directorio: linea en conj.:0x5
Lin. Etq. Ref. ----Directorio:
0x0 0x0 0 Lin. Etq. Ref.
0x1 0x1 2 0x0 0x0 5
Ref. 0xf000, etiqueta=0xf, w=0x0 0x1 0x1 2
----Linea vacia: conjunto:0x0, 0x2 0xf 3
Lin. Etq. Ref. 0x5 0x20 7
0x0 0x0 0 Ref. 0x80000, etiqueta=0x80, w=0x0
0x1 0x1 2 ----Linea vacia: conjunto:0x0,
0x2 0xf 3 linea en conj.:0x6
Ref. 0x10000, etiqueta=0x10, w=0x0 ----Directorio:
----Linea vacia: conjunto:0x0, Lin. Etq. Ref.
Lin. Etq. Ref. 0x2 0xf 3
0x0 0x0 0 0x3 0x10 4
0x1 0x1 2 0x4 0x40 6
0x2 0xf 3 0x5 0x20 7
0x3 0x10 4 0x6 0x80 8
Ref. 0x0, etiqueta=0x0, w=0x0 Estadisticas:
----Exito Referencias: 9
----Directorio: Lineas precargadas: 0
Lin. Etq. Ref. Exitos en referencias: 2
0x0 0x0 5 Exitos incluyendo lineas precargadas: 2
0x1 0x1 2 Fallos incluyendo lineas precargadas: 7
0x2 0xf 3 Fallos compulsorios total: 7
0x3 0x10 4
*ASOCIATIVA CON 4 CONJUNTOS: 0x0 0x0 0x0 0

Param.: n= 4, c= 2, w=12 0x1 0x0 0x0 2
Lineas en cache: 16 Ref. 0xf000, etiqueta=0x3,
Palabras por linea: 4096 c=0x3, w=0x0
Conjuntos: 4 ----Linea vacia: conjunto:0x3,
Lineas por conjunto: 4 linea en conj.:0x0
Reemplazo:FIFO ----Directorio:
No precarga. Cto. Lin. Etq. Ref.
0x0 0x0 0x0 0
Ref. 0x0, etiqueta=0x0, 0x1 0x0 0x0 2
c=0x0, w=0x0 0x3 0x0 0x3 3
----Linea vacia: conjunto:0x0, Ref. 0x10000, etiqueta=0x4,
linea en conj.:0x0 c=0x0, w=0x0
----Directorio: ----Linea vacia: conjunto:0x0,
0x0 0x0 0x0 0 ----Directorio:
Ref. 0x1000, etiqueta=0x0, Cto. Lin. Etq. Ref.
c=0x1, w=0x0 0x0 0x0 0x0 0
----Linea vacia: conjunto:0x1, 0x0 0x1 0x4 4
linea en conj.:0x0 0x1 0x0 0x0 2
----Directorio: 0x3 0x0 0x3 3
Cto. Lin. Etq. Ref. Ref. 0x0, etiqueta=0x0, c=0x0, w=0x0
0x0 0x0 0x0 0 ----Exito
Ref. 0x1001, etiqueta=0x0, Cto. Lin. Etq. Ref.
c=0x1, w=0x1 0x0 0x0 0x0 5
----Exito 0x0 0x1 0x4 4
Cto. Lin. Etq. Ref. 0x3 0x0 0x3 3

c=0x0, w=0x0 0x3 0x0 0x3 3
----Linea vacia: conjunto:0x0, Ref. 0x80000, etiqueta=0x20,
linea en conj.:0x2 c=0x0, w=0x0
----Directorio: ----Reemplazo fifo: conjunto:0x0,
0x0 0x1 0x4 4 Cto. Lin. Etq. Ref.
0x0 0x2 0x10 6 0x0 0x0 0x20 8
0x1 0x0 0x0 2 0x0 0x1 0x4 4
0x3 0x0 0x3 3 0x0 0x2 0x10 6
c=0x0, w=0x0 0x1 0x0 0x0 2
linea en conj.:0x3 Estadisticas:
----Directorio: Rerencias: 9
Cto. Lin. Etq. Ref. Leas precargadas: 0
0x0 0x0 0x0 5 Exitos en referencias: 2
0x0 0x1 0x4 4 Exitos incluyendo lineas precargadas: 2
0x0 0x2 0x10 6 Fallos incluyendo lineas precargadas: 7
0x0 0x3 0x8 7 Fallos compulsorios total: 6
3. Considerar una memoria principal de 64 Kb. estructurada en bytes y la

siguiente secuencia de acceso a memoria principal:
04F5h, 11E0h, 1500h, 2000h, 241Fh, 16FFh,
1233h, 21F0h
Mostrar el contenido del directorio caché, ası́ como los fallos y precar-
gas que se producen para cada una de las cachés descritas en la siguiente
tabla:
Tamaño Tam. lı́nea Organización
Caché 1 4 Kb. 256 bytes Directa; Precarga siempre.
Caché 2 2 Kb. 256 bytes Totalmente asociativa; Pre-
carga bajo fallo; Reemplazo
FIFO.
Caché 3 2 Kb. 256 bytes Asoc. de 2 conjuntos; Sin pre-
carga Reemplazo LRU.
############## CACHE 1: Lin. Etq. Ref.

Param.: n= 4, c= 4, w=8 0x4 0x0 0
Cache de mapeo directo. 0x5 0x0 0
Lineas en cache: 16 Ref. 0x11e0, etiqueta=0x1,
Conjuntos: 16 c=0x1, w=0xe0
Lineas por conjunto: 1 ----Linea vacia: conjunto:0x1,
Precarga:SIEMPRE, linea en conj.:0x0
Lineas a precargar:1 ----Directorio:
Lin. Etq. Ref.
Ref. 0x4f5, etiqueta=0x0, 0x1 0x1 1
c=0x4, w=0xf5 0x4 0x0 0
linea en conj.:0x0 Precarga: 0x12e0, etiqueta=0x1,
----Directorio: c=0x2, w=0xe0
Lin. Etq. Ref. ----Linea vacia: conjunto:0x2,
Precarga: 0x5f5, etiqueta=0x0, ----Directorio:
c=0x5, w=0xf5 Lin. Etq. Ref.
0x5 0x0 0 0x2 0x1 0

Ref. 0x1500, etiqueta=0x1, 0x4 0x2 4
c=0x5, w=0x0 0x5 0x2 2
----Reemplazo: linea:0x5 0x6 0x1 5
----Directorio: Precarga: 0x17ff, etiqueta=0x1,
Lin. Etq. Ref. c=0x7, w=0xff
Precarga: 0x1600, etiqueta=0x1, 0x0 0x2 3
c=0x6, w=0x0 0x1 0x2 1
0x1 0x1 1 0x7 0x1 0
0x2 0x1 0 Ref. 0x1233, etiqueta=0x1,
0x4 0x0 0 c=0x2, w=0x33
0x5 0x1 2 ----Exito
c=0x0, w=0x0 0x0 0x2 3
0x0 0x2 3 0x6 0x1 5
0x1 0x1 1 0x7 0x1 0
0x2 0x1 0 Precarga: 0x1333, etiqueta=0x1,
0x4 0x0 0 c=0x3, w=0x33
Precarga: 0x2100, etiqueta=0x2, ----Directorio:
c=0x1, w=0x0 Lin. Etq. Ref.
----Reemplazo: linea:0x1 0x0 0x2 3
0x0 0x2 3 0x3 0x1 0
0x1 0x2 1 0x4 0x2 4
0x2 0x1 0 0x5 0x2 2
0x4 0x0 0 0x6 0x1 5
0x5 0x1 2 0x7 0x1 0
0x6 0x1 0 Ref. 0x21f0, etiqueta=0x2,
Ref. 0x241f, etiqueta=0x2, c=0x1, w=0xf0
c=0x4, w=0x1f ----Exito
----Reemplazo: linea:0x4 ----Directorio:
----Directorio: Lin. Etq. Ref.
0x0 0x2 3 0x1 0x2 7
0x1 0x2 1 0x2 0x1 6
0x2 0x1 0 0x3 0x1 0
0x4 0x2 4 0x4 0x2 4
0x5 0x1 2 0x5 0x2 2
0x6 0x1 0 0x6 0x1 5
Precarga: 0x251f, etiqueta=0x2, 0x7 0x1 0
c=0x5, w=0x1f Precarga: 0x22f0, etiqueta=0x2,
----Reemplazo: linea:0x5 c=0x2, w=0xf0
----Directorio: ----Reemplazo: linea:0x2
Lin. Etq. Ref. ----Directorio:
0x1 0x2 1 0x0 0x2 3
0x2 0x1 0 0x1 0x2 7
0x4 0x2 4 0x2 0x2 6
0x5 0x2 2 0x3 0x1 0
0x6 0x1 0 0x4 0x2 4
Ref. 0x16ff, etiqueta=0x1, 0x5 0x2 2
c=0x6, w=0xff 0x6 0x1 5
----Exito 0x7 0x1 0
----Directorio:
Exitos en referencias: 3 Fallos incluyendo lineas precargadas: 13

Exitos incluyendo lineas precargadas: 3 Fallos compulsorios total: 8
############## CACHE 2: 0x3 0x12 0

Param.: n= 3, c= 0, w=8 0x4 0x15 2
Lineas en cache: 8 0x5 0x16 0
Conjuntos: 1 0x6 0x20 3
Lineas por conjunto: 8 Precarga: 0x2100, etiqueta=0x21, w=0x0
Reemplazo:FIFO ----Linea vacia: conjunto:0x0,
Precarga:BAJO FALLO linea en conj.:0x7
Lineas a precargar:1 ----Directorio:
Lin. Etq. Ref.
Ref. 0x4f5, etiqueta=0x4, w=0xf5 0x0 0x4 0
0x0 0x4 0 0x5 0x16 0
Precarga: 0x5f5, etiqueta=0x5, w=0xf5 0x6 0x20 3
linea en conj.:0x1 Ref. 0x241f, etiqueta=0x24, w=0x1f
----Directorio: ----Reemplazo fifo: conjunto:0x0,
Lin. Etq. Ref. linea en conj.:0x0
Ref. 0x11e0, etiqueta=0x11, w=0xe0 0x0 0x24 4
0x0 0x4 0 0x5 0x16 0
0x1 0x5 0 0x6 0x20 3
0x2 0x11 1 0x7 0x21 0
Precarga: 0x12e0, etiqueta=0x12, w=0xe0 Precarga: 0x251f, etiqueta=0x25, w=0x1f
----Linea vacia: conjunto:0x0, ----Reemplazo fifo: conjunto:0x0,
linea en conj.:0x3 linea en conj.:0x1
----Directorio: ----Directorio:
Lin. Etq. Ref. Lin. Etq. Ref.
0x0 0x4 0 0x0 0x24 4
0x1 0x5 0 0x1 0x25 0
0x2 0x11 1 0x2 0x11 1
0x3 0x12 0 0x3 0x12 0
Ref. 0x1500, etiqueta=0x15, w=0x0 0x4 0x15 2
Lin. Etq. Ref. Ref. 0x16ff, etiqueta=0x16, w=0xff
0x0 0x4 0 ----Exito
0x3 0x12 0 0x0 0x24 4
0x4 0x15 2 0x1 0x25 0
Precarga: 0x1600, etiqueta=0x16, w=0x0 0x2 0x11 1
0x0 0x4 0 0x7 0x21 0
0x1 0x5 0 Ref. 0x1233, etiqueta=0x12, w=0x33
0x2 0x11 1 ----Exito
0x5 0x16 0 0x0 0x24 4
Ref. 0x2000, etiqueta=0x20, w=0x0 0x1 0x25 0
0x0 0x4 0 0x6 0x20 3
0x1 0x5 0 0x7 0x21 0
0x2 0x11 1 Ref. 0x21f0, etiqueta=0x21, w=0xf0
----Exito 0x6 0x20 3

0x2 0x11 1 Exitos en referencias: 3
0x3 0x12 6 Exitos incluyendo lineas precargadas: 3
0x4 0x15 2 Fallos incluyendo lineas precargadas: 10
0x5 0x16 5 Fallos compulsorios total: 8
############## CACHE 3: 0x0 0x1 0x10 3

Param.: n= 3, c= 1, w=8 0x0 0x2 0x12 4
Lineas en cache: 8 0x1 0x0 0x8 1
Palabras por linea: 256 0x1 0x1 0xa 2
Conjuntos: 2 Ref. 0x16ff, etiqueta=0xb,
Lineas por conjunto: 4 c=0x0, w=0xff
Reemplazo:LRU ----Linea vacia: conjunto:0x0,
No precarga linea en conj.:0x3
----Directorio:
Ref. 0x4f5, etiqueta=0x2, c=0x0, w=0xf5 Cto. Lin. Etq. Ref.
Cto. Lin. Etq. Ref. 0x0 0x3 0xb 5
0x0 0x0 0x2 0 0x1 0x0 0x8 1
Ref. 0x11e0, etiqueta=0x8, 0x1 0x1 0xa 2
c=0x1, w=0xe0 Ref. 0x1233, etiqueta=0x9,
----Linea vacia: conjunto:0x1, c=0x0, w=0x33
linea en conj.:0x0 ----Reemplazo lru: conjunto:0x0,
----Directorio: linea en conj.:0x0
Cto. Lin. Etq. Ref. ----Directorio:
0x0 0x0 0x2 0 Cto. Lin. Etq. Ref.
0x1 0x0 0x8 1 0x0 0x0 0x9 6
Ref. 0x1500, etiqueta=0xa, 0x0 0x1 0x10 3
c=0x1, w=0x0 0x0 0x2 0x12 4
----Linea vacia: conjunto:0x1,
linea en conj.:0x1 0x0 0x3 0xb 5
Cto. Lin. Etq. Ref. 0x1 0x1 0xa 2
0x0 0x0 0x2 0 Ref. 0x21f0, etiqueta=0x10,
0x1 0x0 0x8 1 c=0x1, w=0xf0
0x1 0x1 0xa 2 ----Linea vacia: conjunto:0x1,
Ref. 0x2000, etiqueta=0x10, linea en conj.:0x2
c=0x0, w=0x0 ----Directorio:
----Linea vacia: conjunto:0x0, Cto. Lin. Etq. Ref.
Cto. Lin. Etq. Ref. 0x0 0x2 0x12 4
0x0 0x0 0x2 0 0x0 0x3 0xb 5
0x0 0x1 0x10 3 0x1 0x0 0x8 1
0x1 0x0 0x8 1 0x1 0x1 0xa 2
0x1 0x1 0xa 2 0x1 0x2 0x10 7
Ref. 0x241f, etiqueta=0x12, Estadisticas:
c=0x0, w=0x1f Referencias: 8
----Linea vacia: conjunto:0x0, Lineas precargadas: 0
linea en conj.:0x2 Exitos en referencias: 0
----Directorio: Exitos incluyendo lineas precargadas: 0
Cto. Lin. Etq. Ref. Fallos incluyendo lineas precargadas: 8
0x0 0x0 0x2 0 Fallos compulsorios total: 7
4. Disponemos de una memoria caché de 4 Kb. con tamaño de lı́nea de

256 bytes, organización asociativa de 8 conjuntos, algoritmo de precarga
bajo fallo y algoritmo de reemplazo LRU.
Conectamos la caché entre un procesador de 8 bits y una memoria
principal de 1 Mb. Se pide:
a) Diseñar la memoria principal de manera que se optimice la trans-

ferencia de información entre caché y memoria principal.
b) Suponiendo la caché inicialmente vacı́a, describir la evolución del
directorio caché para la siguiente secuencia de petición de direccio-
nes a memoria principal:
319F0h, 31AF0h, 7013Ch, 77777h, 44037h,
778DEh, A5021h
Indicar claramente el ciclo en el que entra cada dato en el directorio
caché, ası́ como su etiqueta identificativa dentro de éste.
c) Comparar el sistema anterior con respecto a criterios de rendimiento
y coste frente a una caché organizada de forma directa y a otra
totalmente asociativa.
5. Considerar una memoria asociativa organizada en palabras de 8 bits.
Realizar algoritmos para implementar las operaciones de búsqueda que
se muestran a continuación, indicando a cada paso los valores del registro
comparando (C) y del registro máscara (M). Todos los algoritmos deben
ser independientes del número de celdas de la memoria.
a) Los números que no sean iguales al 01101110.
b) Los números múltiplos de 4, bien menores a -38 ó bien comprendidos
entre 0 y 82, considerando representación signo-magnitud.
c) Los números comprendidos entre 20 y 30.
Solución:
(a) Buscamos los números que difieran en el primer bit, los que di-
fieran en el segundo, .... (se puede hacer de diversas maneras, con esta
intentamos hacer busquedas disjuntas de patrones).
1. M=1000 0000; C=1110 1110; Búsqueda. (Patrón 1xxxxxxx)
2. M=1100 0000; C=0010 1110; Búsqueda. (Patrón 00xxxxxx)
3. M=1110 0000; C=0100 1110; Búsqueda. (Patrón 010xxxxx)
4. M=1111 0000; C=0111 1110; Búsqueda. (Patrón 0111xxxx)
5. M=1111 1000; C=0110 0110; Búsqueda. (Patrón 01100xxx)
6. M=1111 1100; C=0110 1010; Búsqueda. (Patrón 011010xx)
7. M=1111 1110; C=0110 1100; Búsqueda. (Patrón 0110110x)
8. M=1111 1111; C=0110 1111; Búsqueda. (Patrón 01101111)
(b) En binario: +82=0 1010010 y -38=1 0100110. Buscamos primero
los positivos menores a 82 y multiplos de 4. Denotamos con 0 el bit
menos significativo y con 7 el más significativo:
1. C=00000000, M=11000011; Búsqueda. (Patrónes 00xxxx00)
2. C=01000000, M=11110011; Búsqueda. (Patrónes 0100xx00)
3. C=01010000, M=11111111; Búsqueda. (Patrón 01010000)

Y luego los negativos: es decir aquéllos cuyos últimos 7 bits corres-
ponda a un valor mayor a 38, su bit más significativo sea 1 y los bits 1
y 0 sean 0.
4. C=11000000, M=11000011; Búsqueda. (Patrón 11xxxx00)
5. C=10110000, M=11110011; Búsqueda. (Patrón 1011xx00)
6. C=10101000, M=11111011; Busqueda. (Patrón 10101x00)
6. Supongamos una caché totalmente asociativa compuesta por 4 lı́neas, y
un programa compuesto por un bucle que se ejecuta 1000 veces y solicita
las lı́neas A-B-C-D-E de memoria principal en cada iteración, siguiendo
la secuencia A, B, C, D, E, A, C. Sabiendo que el número de accesos a
cada lı́nea de memoria principal por cada iteración del bucle es A:100,
B:5, C:6, D:4 y E:10, calcular el ı́ndice de fallos si utilizamos el algoritmo
de reemplazo LRU. Idem para el algoritmo FIFO.
7. Sea un procesador de 16 bits con un bus de direcciones de 24 bits al que
se le quiere dotar de un sistema de memoria caché con las siguientes ca-
racterı́sticas: Organización totalmente asociativa, 8 lı́neas de 16 palabras
cada una, precarga bajo fallo y algoritmo de reemplazo FIFO.
a) Diseñar un sistema de memoria principal a partir de pastillas de
256Kx8 de forma que la transferencia de información entre memoria
principal y caché sea lo más rápida posible.
b) Dado el estado inicial de la caché que aparece en la siguiente tabla,
indicar la evolución del directorio caché para la siguiente secuencia
de referencias a memoria: 0A3014h, 12345Bh, BB2303h, C0E50Fh,
C0E4F3h. Las lı́neas entraron en la caché siguiendo el orden que
aparece en la tabla. Suponer que una lı́nea precargada cuenta como
una lı́nea cualquiera a la hora de aplicar el algoritmo FIFO.
Número de lı́nea Etiqueta para los datos de esa lı́nea
0 0A301h
1 43A02h
2 12345h
3 AC0C3h
4 C0E50h
5 BB232h
6 11E91h
7 11E92h
8. Considera el siguiente código ensamblador del i8086, en el que se facilita

el desplazamiento (offset), referido a cada segmento, de las etiquetas y/o
instrucciones:
0000 DATOS SEGMENT
0000 TABLA1 DW 128 DUP(1)
0100 TABLA2 DW 128 DUP(0)
0200 DATOS ENDS
;-------------------------
0000 PILA SEGMENT STACK
0000 DB 512 DUP(0)
0200 PILA ENDS
;-------------------------
0000 CODIGO SEGMENT
ASSUME CS:CODIGO,DS:DATOS,SS:PILA
0000 INICIO: MOV AX, SEG DATOS
0003 MOV DS, AX
0005 XOR SI, SI
0007 BUCLE: MOV BX, TABLA1[SI]
000B ADD BX, TABLA2[SI]
000F MOV TABLA1[SI], BX
0013 ADD SI, 02H
0016 CMP SI, 128
001A JNE BUCLE
001C FINP: MOV AH,4CH
001E INT 21H
0020 CODIGO ENDS
END INICIO
a) Escribe la traza de la ejecución mostrando las palabras de memo-
ria referenciadas diciendo si se trata de búsqueda de instrucción,
lectura o escritura de datos. Suponga para ello que los registros de
segmentos son: DS=200H, SS=220H, CS=240H.
b) Dado que el bus de datos es de 16 bits, diseñe un esquema de
memoria entrelazada para este procesador que conste de 2 bancos
de memoria cada uno direccionado a nivel de byte.
c) Con una pequeña caché de 1Kbyte, con tamaño de palabra de 2
bytes, tamaño de lı́nea de 4 palabras, ¿cuál es la tasa de fallos para
la ejecución de este programa en los siguientes casos: completa-
mente asociativa, de mapeo directo, asociativa por conjuntos con
8 conjuntos? Suponga que no hay precarga y la actualización es
write-through.
d) ¿Y si dicha caché se dividiera en dos: una para referencias a datos
y otra para instrucciones?
Solución:
Nos vamos a centrar en la ejecución del bucle. Puesto que éste se
ejecuta 64 veces solo vamos a analizar las 2 primeras iteraciones: (Con
R indicamos lectura de datos, W escritura de datos e I búsqueda de
instrucción). Las direcciones corresponden a posiciones fı́sicas del byte
referenciado. (Para el segmento de código la posición fı́sica se calcula
como CS*10H+offset y para el de datos DS*10H+offset). Se indica el
numero de bytes transferidos en cada referencia.

1 iteración: I 2407H ; instrucción MOV BX, TABLA1[SI] 4 bytes
R 2000H ; comienzo TABLA1 2 bytes
I 240BH ; instrucción MOV BX, TABLA2[SI] 4 bytes
R 2100H ; comienzo TABLA2 2 bytes
I 240FH ; instrucción MOV TABLA1[SI], BX 4 bytes
W 2000H ; comienzo TABLA1 2 bytes
I 2413H ; instrucción ADD SI, 02H 3 bytes
I 2416H ; instrucción CMP SI, 128 4 bytes
I 241AH ; instrucción JNE 2 bytes
2 iteracion: I 2407H ; instrucción MOV BX, TABLA1[SI]
R 2002H ; comienzo TABLA1 + 2
I 240BH ; instrucción MOV BX, TABLA2[SI]
R 2102H ; comienzo TABLA2 + 2
I 240FH ; instrucción MOV TABLA1[SI], BX
W 2002H ; comienzo TABLA1 + 2
I 2413H ; instrucción ADD SI, 02H
I 2416H ; instrucción CMP SI, 128
I 241AH ; instrucción JNE
.........................................
A la hora de simular la traza anterior hay que tener en cuenta las
siguientes indicaciones:
- Los parametros a fijar: n=9; w=2;
- Obtener la direccion de palabra asociada a cada referencia
ya que las peticiones están expresadas en direcciones a nivel
de byte.
- Como las palabras son de 2 bytes pero las referencias son
de bytes, el acceso a una palabra que empieza en una posicion
par solo implica un acceso a memoria, mientras que el acceso
a una palabra que empieza en una posicion impar necesita dos
accesos a memoria.
Apéndice E
Solución a las relaciones de

problemas
E.1. REPRESENTACIÓN DE LA INFORMACIÓN
Representación de los datos
1. Convierte los siguientes números decimales a binario: 1984, 4000, 8192.

Solución: 11111000000, 111110100000,
213 =10000000000000
2. ¿Qué número es 1001101001(2 en decimal? ¿En octal? ¿En hexadecimal?
Solución: 1001101001(2 = 617(10 = 1151(8 = 269(16
3. ¿Cuáles de éstos son números hexadecimales válidos?: CAE, ABAD,
CEDE, DECADA, ACCEDE, GAFE, EDAD. Pasar los números válidos
a binario.
Solución:
CAE = 1100 1010 1110
ABAD = 1010 1011 1010 1101
CEDE = 1100 1110 1101 1110
DECADA = 1101 1110 1100 1010 1101 1010
ACCEDE = 1010 1100 1100 1110 1101 1110
EDAD = 1110 1101 1010 1101
4. Expresa el número decimal 100 en todas las bases, de 2 a 9.
Solución: 100(10 = 121(9 = 144(8 = 202(7 = 244(6 = 400(5 =
1210(4 = 10201(3 = 1100100(2
5. ¿Cuántos enteros positivos se pueden representar con k dı́gitos usando
249
números en base r?
Solución: Variaciones con repetición de r elementos tomados de k en
k, es decir, RVrk = r k .
6. El siguiente conjunto de 16 bits:
1001 1000 0101 0100
puede representar un número que depende del convenio utilizado.
Dar su significación decimal en el caso de que el convenio sea:
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
d) BCD natural (8,4,2,1)
e) BCD exceso a 3
f) BCD Aiken (2,4,2,1)
Solución:
a) Signo y Magnitud = -6228
b) Complemento a 1 = -26539
c) Complemento a 2 = -26540
d) BCD natural (8,4,2,1) = 9854
e) BCD exceso a 3 = 6521
f) BCD Aiken (2,4,2,1) = sólo válido el 4 final
7. Para las siguientes representaciones de n bits, dar el rango, precisión,
representaciones del 0 y comparar el número de números positivos con
el de negativos.
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
Solución:
Formato Rango Precisión Cero(s)

Sig/Mag [−(2n−1 − 1), 2n−1 − 1] 2n − 1 10..0/00..0
C1 [−(2 n−1 − 1), 2n−1 − 1] 2n − 1 11..1/00..0
C2 [−2n−1 , 2n−1 − 1] 2n 00..0
8. Expresar los números decimales -63, 91 y -23 en signo/magnitud, en

complemento a uno y en complemento a dos utilizando una palabra de
8 bits.
Solución:
APÉNDICE B. SOLUCIÓN A LAS RELACIONES DE PROBLEMAS 251
Formato N.o Positivos N.o Negativos

Sig/Mag 2n−1 − 1 2n−1 − 1
C1 2n−1 − 1 2n−1 − 1
C2 2n−1 − 1 2n−1
Número Sig/Magnitud C1 C2
-63 1011 1111 1100 0000 1100 0001
91 0101 1011 0101 1011 0101 1011
-23 1001 0111 1110 1000 1110 1001
9. ¿Cuántos bits son necesarios para representar todos los números entre
-1 y +1 con un error no mayor de 0.0001(10 en complemento a dos y con
notación en punto fijo?
5 6
Solución: n = ceil log2 ( 102−4 + 1) = 15
10. Representar los siguientes números como flotantes IEEE-754 en simple
precisión.
a) 10
b) 10.5
c) 0.1
d) 0.5
e) -23.15625
Solución:
a) 10 = 0 1000 0010 0100 0000 ... 0
b) 10.5 = 0 1000 0010 0101 0000 ... 0
c) 0.1 = 0 0111 1011 1001 1001 1001 1001 ... 1001
d) 0.5 = 0 0111 1110 0000 ... 0
e) -23.15625 = 1 1000 0011 0111 0010 1000 0000 ... 0
11. ¿Qué inconveniente encontramos en la representación de números rea-
les en punto fijo? Dados estos dos números en el formato IEEE 754:
C0E80000 y 00080000; decir qué valores representan en decimal.
Solución:
Limita el rango y la precisión y presenta el problema del escalado.
C0E80000(H = -7.25(10 ; 00080000(H = 1 x 2−130 (10
12. ¿Cuáles son los requisitos deseables de un sistema de numeración de
enteros con signo? ¿Qué sistema cumple mejor esos requisitos? Expresar
el número 9.75 en su representación IEEE 754 de 32 bits (convierte a
hexadecimal la palabra IEEE de 32 bits).

Solución:
Requisitos: igual número de valores positivos y negativos, detección
simple del signo y del cero e implementación sencilla de las operaciones
aritméticas básicas. El Complento a 2.
0 1000 0010 0011 1000 0000 ... 0 = 411C0000(H
13. En una PDP-11 los números en punto flotante de precisión sencilla tienen
un bit de signo, un exponente en exceso a 128 y una mantisa de 24 bits.
Se exponencia a la base 2. El punto decimal está en el extremo izquierdo
de la fracción. Debido a que los números normalizados siempre tienen
el bit de la izquierda a 1, éste no se guarda; solo se guardan los 23 bits
restantes. Expresa el número 7/64 en este formato.
Solución: 0 0111 1100 1100 0000 ... 0
14. Expresa el número 7/64 en el formato IBM/360, y en el formato IEEE-
754.
Solución:
a) IBM/360 : 0 100 0000 0001 1100 0000 ... 0
b) IEEE-754 : 0 0111 1011 1100 0000 0000 ... 0
15. Expresa el número en punto flotante de 32 bits 3FE00000 (16 como nú-
mero decimal si está representado en los siguientes formatos de 32 bits:
a) IEEE-754
b) IBM/360
c) PDP-11
Solución:
a) IEEE-754 : 1.75
b) IBM/360 : 0.0546875
c) PDP-11 : 0.875
16. Los siguiente números en punto flotante constan de un bit de signo,
un exponente en exceso a 64 y una mantisa de 16 bits. Normalı́zalos
suponiendo que la exponenciación es a la base 2 y que el formato NO es
del tipo 1.XXXX... con el “1” implı́to.
0 1000000 0001010100000001
0 0111111 0000001111111111
0 1000011 1000000000000000
Solución:
0 0111101 1010100000001000
0 0111001 1111111111000000
Ya está normalizado
17. ¿Cuál son los números positivos más pequeño y más grande representa-
bles para los siguientes convenios?:
a) IEEE-754
b) IBM/360
c) PDP-11
Solución:
a) IEEE-754 : m = 1.0 x 2−126 (Mirar nota al pie 1 ); M ≈ 2 x 2127
b) IBM/360 : m = 0.0001 x 16−64 ; M ≈ 1 x 1663
c) PDP-11 : m = 1.0 x 2−128 ; M ≈ 2 x 2127
Representación de las instrucciones

1. Diseña un código de operación con extensión que permita lo siguiente y
se pueda codificar en una instrucción de 36 bits:
gistro de 3 bits,
registro de 3 bits,
c) 50 instrucciones sin direcciones ni registros.
Solución:
gistro de 3 bits:
C.O. (3) Dirección1 (15) Dirección2 (15) Registro (3)
con C.O. de 001 (1) a 111 (7).
registro de 3 bits:
000 (3) C.O. (9) Dirección 1 (15) Registro (3) XXX XXX (6)
con C.O. de 000000001 (1) a 111110100 (500).
c) 50 instrucciones sin direcciones ni registros:
000 (3) 000000000 (9) C.O.(6) XXX ... X (18)
con C.O. de 000000 (0) a 110001 (49).
2. ¿Es posible diseñar un código de operación con extensión que permi-
ta codificar lo siguiente en una instrucción de 12 bits? Un registro se
direcciona con 3 bits.
a) 4 instrucciones con tres registros,
1
Si consideramos números desnormalizados m= 1.0 x 2−149
b) 255 instrucciones con un registro,

c) 16 instrucciones con cero registros.
Solución: No. Si hacemos el diseño vemos que nos falta un bit.
a) 4 instrucciones con tres registros:
C.O. (3) R1 (3) R2 (3) R3 (3)
con C.O. de 000 a 011.
b) 255 instrucciones con un registro:
1 (1) C.O. (8) REG (3)
con C.O. de 00000000 a 11111110.
c) 16 instrucciones con cero registros:
1 (1) 11111111 (8) C.O. (3)
Sólo nos quedan 3 bits, con lo que se podrán codificar como máximo
8 instrucciones con cero registros.
3. Cierta máquina tiene instrucciones de 16 bits y direcciones de 6. Algunas
instrucciones tienen una dirección y otras dos. Si hay n instrucciones
de dos direcciones, ¿cuál es el número máximo de instrucciones de una
dirección?
Solución: (16 − n) · 64
4. Queremos diseñar el formato de instrucciones de un microprocesador
con 16 registros internos, y que puede direccionar 1 Kbyte de memoria.
Dentro del conjunto de instrucciones encontramos las siguientes:
a) 15 instrucciones del tipo:
Código de Op. Desp, Dirección, Dirección
b) 63 instrucciones del tipo:
Código de Op. Desp, Dirección, Registro
c) 60 instrucciones del tipo:
Código de Op. Dirección, Registro
d) 15 instrucciones del tipo:
Código de Op. Registro, Registro, Registro
e) 16 instrucciones del tipo:
Código de Op.
Donde el campo desplazamiento (Desp) nos permite implementar el
direccionamiento relativo, desplazándonos como máximo 63 bytes res-
pecto de la dirección base apuntada por la primera Dirección. El despla-
zamiento siempre será positivo.
Se pide:
a) Decir de cuántas direcciones es cada tipo de instrucciones (0, 1, 2

ó 3).
b) Diseñar el formato de cada tipo de instrucciones mediante códigos
Solución:
Decir de cuántas direcciones es cada tipo de instrucciones (0, 1, 2
ó 3).
(a) 2, (b) 2, (c) 2, (d) 3, (e) 0.
Diseñar el formato de cada tipo de instrucciones mediante códigos
Desplazamiento → 6 bits, Dirección → 10 bits, Registro → 4 bits.
a) C.O. (4) Desp (6) Dir (10) Dir (10)
b) 1111 (4) C.O. (6) Desp (6) Dir (10) Reg (4)
c) 1111 (4) 111111 (6) C.O. (6) Dir (10) Reg (4)
con C.O. de 000000 (0) a 111011 (59).
d) 1111 (4) 111111 (6) 1111XX (6) C.O.(2) Reg(4) Reg(4) Reg(4)
Para codificar las 16 instrucciones usamos XX de 00 a 11 (co-
rrespondientes a los códigos de operación 60 a 63 del formato
anterior) junto con los dos bits indicados. Reservamos XX=11
y CO=11 para especificar el siguiente formato:
e) 1111(4) 111111(6) 111111(6) 11 (2) C.O.(4) XX...X(8)
Se necesitarán por lo tanto 30 bits para codificar todas las posibles

instrucciones.
5. Dados los contenidos de las celdas de memoria que siguen y una máquina
de una dirección con un acumulador, ¿qué valores cargan en el acumu-
lador las instrucciones siguientes?
a) LOAD 20
b) LOAD [20]
c) LOAD [[20]]
d) LOAD 30
e) LOAD [30]
f) LOAD [[30]]
Solución:
a) LOAD 20 ⇒ AC ← 20
b) LOAD [20] ⇒ AC ← 40
c) LOAD [[20]] ⇒ AC ← 60
d) LOAD 30 ⇒ AC ← 30
e) LOAD [30] ⇒ AC ← 50
f) LOAD [[30]] ⇒ AC ← 70
6. Compara las máquinas de 0, 1, 2, y 3 direcciones escribiendo programas
para calcular
X = (A + B × C)/(D − E × F )
para cada una de las cuatro máquinas. Para que no se pierdan los valores
originales de las variables A, B, C, D, E y F podremos apoyarnos en
una variable temporal T. Suponiendo direcciones de 16 bits, códigos de
operación de 8 bits y longitudes de instrucción que son múltiplos de 4
bits, ¿Cuántos bits necesita cada computadora para calcular X?
Solución:
3 Direcciones
MUL B, C, T
ADD A, T, T
MUL E, F, X
SUB D, X, X
DIV T, X, X
Bits necesarios: 5 x (8 + 3 x 16) = 280.
2 Direcciones
MOVE C, T
MUL B, T
ADD A, T
MOVE F, X
MUL E, X
SUB D, X
DIV T, X
Bits necesarios: 7 x (8 + 2 x 16) = 280.
1 Dirección
LOAD C
MUL B
ADD A
STORE T
LOAD F
MUL E
SUB D
DIV T
STORE X
Bits necesarios: 9 x (8 + 16) = 216.
0 Direcciones (usando una pila)
PUSH A
PUSH B
PUSH C
MUL
ADD
PUSH D
PUSH E
PUSH F
MUL
SUB
DIV
POP X
Bits necesarios: 5 x 8 + 7 x (8 + 16) = 208.
E.2. PROCESADOR CENTRAL
1. Para el número de 16 bits: 1001 0101 1100 0001 almacenado en el registro

AX, muestra el efecto de:
a) SHR AX, 1
b) SAR AX, 1
c) SAL AX, 1
d) ROL AX, 1
e) ROR AX, 1
Solución:
a) SHR AX, 1 ⇒ 0100 1010 1110 0000 CF=1
b) SAR AX, 1 ⇒ 1100 1010 1110 0000 CF=1
c) SAL AX, 1 ⇒ 0010 1011 1000 0010 CF=1
d) ROL AX, 1 ⇒ 0010 1011 1000 0011 CF=1
e) ROR AX, 1 ⇒ 1100 1010 1110 0000 CF=1
2. ¿Cómo podrı́as poner a 0 el registro AX si no dispones de una instrucción
de BORRAR (CLEAR)?
Solución: De menos a más eficientemente:
a) SHL AX, 16
b) MOV AX, 0
c) SUB AX, AX
d) XOR AX, AX
3. Inventa un método para intercambiar dos registros (AX y BX) sin usar
un tercer registro o variable ni la instrucción XCHG. Sugerencia: piensa
en la instrucción OR EXCLUSIVO.
Solución:
XOR AX, BX
XOR BX, AX
XOR AX, BX

memoria. Escribir un programa en ensamblador del 8086 que cuente los
números P ≥ 0 y N < 0 y que almacene P en la posición 1000 de
memoria y N en la 1002.
Solución:
XOR AX, AX ; P=0
XOR BX, BX ; N=0
MOV DI, 500
MOV CX, 250
LAZO: MOV DX, [DI]
ADD DI, 2
CMP DX, 0
JL NEGA ; Salta si menor que cero
INC AX
JMP CONT
NEGA: INC BX
CONT: LOOP LAZO
MOV [1000], AX
MOV [1002], BX
END
Otro posible algoritmo sólo contarı́a los positivos y luego calcuları́a los nega-
tivos restando de 250. Esto es más eficiente ya que nos evitamos los incrementos
del registro BX, un salto incondicional y el XOR BX, BX. También podemos ha-
cer la comparación con el dato de memoria directamente sin copiarlo en un
registro, ya que la instrucción CMP no modifica los operandos (sólo actualiza los
flags despues de restar, pero no guarda el resultado en ningún sitio):
XOR AX, AX ; P=0

MOV DI, 500
MOV CX, 250
LAZO: CMP [DI], 0
JL CONT
INC AX
CONT: ADD DI, 2
LOOP LAZO
MOV [1000], AX
SUB AX, 250; AX=AX-250
NEG AX
MOV [1002], AX
END
5. Tenemos 100 números positivos de 16 bits en las posiciones de memoria 1000 a

1198. Escribir un programa que determine cuál es el número mayor de todos y
lo almacene en la posición 1200.
Solución:
MOV CX, 99
MOV DI, 1000
MOV AX, [DI]; tomar el primer numero
ADD DI, 2
LAZO: CMP AX, [DI]
JG SIGUE
MOV AX, [DI]
SIGUE: ADD DI, 2
LOOP LAZO
MOV [DI], AX
END
6. Escribir un procedimiento en lenguaje ensamblador del 8086 que calcule N! y

lo almacene en la posición de memoria 502. Supondremos que 1<N<255, que
el número N está en la posición 500 de memoria y que N! cabe en un registro
de 8 bits.
Solución:
XOR CX, CX
MOV AL, [500]
MOV CL, AL
DEC CL
BUCLE: MUL CL
LOOP BUCLE
MOV [502], AX
END
7. Escribir una subrutina en lenguaje ensamblador que convierta un entero binario

positivo (menor que 1000 y almacenado en la posición 2000 de memoria) a
ASCII, guardando cada carácter a partir de la posición 3000 de memoria. Por
ejemplo, el número 345 debe traducirse a los caracteres ASCII 3, 4 y 5 (33H,
34H y 35H en hexadecimal respectivamente)
Solución:
MOV DI, 3002
MOV CX, 3 ; cifras
MOV AX, [2000]
MOV BX, 10
BUCLE: DIV BL
ADD AH, 30h
MOV [DI], AH
DEC DI
MOV AH, 0
LOOP BUCLE
END
8. a)Escribe el diagrama de flujo y el programa en ensamblador del 8086 de

Intel para el algoritmo que realiza la siguiente función:
Dada una tabla en la posición 100 de memoria con 50 números de
16 bits en complemento a dos, multiplicar por 2 los números pares
y dividir por 2 los impares (división entera), dejando cada número
modificado en la misma posición de la tabla en la que estaba. No
utilizar las instrucciones MUL y DIV. No considerar el caso de
overflow al multiplicar por dos.
b) ¿Qué diferencia hay entre los desplazamientos lógicos y aritméticos a la
derecha?
Solución:
a) El diagrama de flujo y el código resultante pueden verse a continuación.
Hay que tener en cuenta que en los números impares negativos se pierde
el bit menos significativo (a 1), con lo que el resultado quedará en C1.
Habrá que sumar uno en este caso para tenerlo en C2.
MOV SI, 100
MOV CX, 50
LAZO: MOV AX, [SI]
SAR AX, 1
JC IMPAR
PAR: SAL AX, 2
JMP CONT
IMPAR: CMP AX, 0
JGE CONT ; salta si es positivo
ADD AX, 1
Inicializacion
Leer dato
SAR
No Si (impar)
CF?
SAL 2 Suma 1 a <0
Escribe dato
Si
Mas?
No
FIN
Figura E.1: Diagrama de Flujo del programa del problema 8
CONT: MOV [SI], AX

ADD SI, 2
LOOP LAZO
END
b) En los desplazamientos aritméticos a la derecha se produce extensión de

signo y en los lógicos se introducen 0s. Mirar ejercicio 1.
9. Escribe el diagrama de flujo y el programa en ensamblador del 8086 de Intel
para el algoritmo que realiza la siguiente función:
Dada una tabla en la posición 500 de memoria con 50 números de
16 bits en complemento a dos, forzar a cero los números negativos y
multiplicar por tres los positivos, dejando cada número modificado en
la misma posición de la tabla en la que estaba. No utilizar ninguna
instrucción de multiplicar (MUL). No considerar el caso de overflow al
multiplicar por tres.
Solución:
Inicializacion
Leer dato en AX
Si (negativo) No
AX<0
MOV BX, AX
AX = 0 SAL AX, 1
ADD AX, BX
Escribe dato
Si
Mas?
No
FIN
Figura E.2: Diagrama de Flujo del programa del problema 9
MOV SI, 500

MOV CX, 50
LAZO: MOV AX, [SI]
CMP AX, 0
JG POSI
MOV AX, 0
JMP CONT
POSI: MOV BX, AX
SAL AX, 1
ADD AX, BX
CONT: MOV [SI], AX
ADD SI, 2
LOOP LAZO
END
10. Suponga que el contenido de la memoria de un sistema basado en el i8086 es

el que se muestra en la tabla E.1. El valor de los registros es: DS=SS=E000H,
SI=0001H, DI=0002H, BP=0003H, BX=0004H. Se define ası́ mismo una eti-
queta TABLA, que apunta a la dirección fı́sica E0001H y que pertence al segmento
de datos.
Para cada una de las siguientes instrucciones, determine como quedan afec-
tados los registros correspondientes:
posición fı́sica contenido

..... .....
E0006 DE H
E0005 BC H
E0004 9A H
E0003 78 H
E0002 56 H
E0001 34 H <-- TABLA
E0000 12 H
..... .....
5D276 07 H
5D275 06 H
5D274 05 H
5D273 04 H
5D272 03 H
5D271 02 H
5D270 01 H
..... .....
Tabla E.1: Contenido de la memoria
MOV AX, [TABLA]

MOV AX, [SI]
MOV AL, [SI]
MOV AX, [SI+2]
MOV AX, TABLA[SI]
MOV AL, TABLA[SI]
MOV AH, TABLA[SI]
MOV AX, [BP+2]
MOV AX, [BX+SI]
MOV AX, [BP+SI]
MOV AL, [BP+SI+1]
MOV AH, TABLA[BX][SI]
LEA AX, TABLA
LEA DI, TABLA[SI+1]
MOV AX, SEG TABLA
MOV CX, OFFSET TABLA
Solución:
MOV AX, [TABLA] ; AX = 5634H
MOV AX, [SI] ; AX = 5634H
MOV AL, [SI] ; AL = 34H
MOV AX, [SI+2] ; AX = 9A78H
MOV AX, TABLA[SI] ; AX = 7856H
MOV AL, TABLA[SI] ; AL = 56H
MOV AH, TABLA[SI] ; AH = 56H

MOV AX, [BP+2] ; AX = DEBCH
MOV AX, [BX+SI] ; AX = DEBCH
MOV AX, [BP+SI] ; AX = BC9AH
MOV AL, [BP+SI+1] ; AL = BCH
MOV AH, TABLA[BX][SI] ; AH = DEH
LEA AX, TABLA ; AX = 0001H
LEA DI, TABLA[SI+1] ; DI = 0003H
MOV AX, SEG TABLA ; AX = E000H
MOV CX, OFFSET TABLA ; CX = 0001H
E.3. SECCIÓN DE CONTROL
Nos limitamos en este apartado a presentar los contenidos de la ROM de

microprograma y la ROM de Proyección para cada uno de los ejercicios. Los
bits no especificados se suponen puestos a cero.
ROM de Proyección del problema 4
Dir 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Cont. 8 10 4 5
Dir 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Cont. 11 7 5 3
Dir 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Cont. 6 11 4 9
Nota: En las siguientes tablas en la columna “Descripción” se muestra

en pseudocódigo la acción que realiza cada microinstrucción. La abreviatura
DEC. se ha empleado para indicar la decodificación, que implica la carga
del contador de microprograma con el contenido de la posición de la ROM
de proyección seleccionada por el registro de instrucción (RI), es decir, la
operación µP C ⇐ ROMproyección (RI).
L R C De X Mem ALU F M Salto
Comentario Dir. b1 b2 b3 b4 b5 b6 b7 b8 b9 b10 b11 b12 b13 b14 b15 b16 b17 b18 CS Dir. Salto
(PC) → RI 0 0 1 1
PC++; DEC. 1 0 1 1 1 1 0 1 1 1 1
Z? 2 1 0 00000 00100
PC++. Salto Fetch 3 0 1 1 1 1 0 1 1 1 00000 00000
(PC) → D 4 1 0 0
D → PC 5 0 1 0 1 0 1 1 1 00000 00000
A-B. C? 6 1 0 0 0 1 1 0 1 1 0 1 00000 01000
Salto Fetch 7 1 1 00000 00000
A → B. Salto 8 1 0 0 1 1 1 1 00000 00000
A→ I 9 1 0 0 0 1
B→ A 10 1 1 0 1 0
I→B 11 0 1 0 1 1 1 1 00000 00000
APÉNDICE B. SOLUCIÓN A LAS RELACIONES DE PROBLEMAS
Tabla E.2: Memoria de microprograma para los problemas 1, 2 y 3

265
Registros ALU PC Mem. MAR DR Salto

Comentario Dir. c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 c20 CS Dir. Salto
PC → MAR 0 0 0 1 1
PC++, MEM → DR 1 1 0 0 1 1
DR → RI 2 0 0 0 1 1
DEC. 3 1 11 0
A → TMP 4 0 0 1 0 1 0 0 1 1 0 0 11 0
A → MAR 5 1 0 0 1 1 0 0 1
MEM → DR 6 1 1
DR → B 7 0 1 0 0 1 11 0
Z? 8 10 0
A → PC 9 1 0 0 1 1 0 0 0 1 0 11 0
A → MAR 10 1 0 0 1 1 0 0 1
MEM → DR 11 1 1
DR → TMP 12 0 0 1 0 1
B× TMP → B 13 0 1 0 0 0 1 1 0 1 1 0 11 0
Tabla E.3: Problema 4. Memoria de microprograma
266
LOAD CLR BUS INC SH M CS DIR
Comentario Dir. c1 c2 c3 c4 c5 c6 c7 c8 c9 CS Dir. Salto
Clear AC y Cont. 100 1
Si x(0) salta a 103 101 10 0110 0111 (103)
Suma 102 1
Shift, Inc, FIN? 103 1 1 01 0000 0000
Salta 101 104 11 0110 0101 (101)

267
Banco de Reg. AC, RI, DR ALU SR Mem. Cte Salto

Comentario Dir. c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 c19 CS Dir. /Cte.
DR ⇐ (PC); AC 0 1 1 1 1 1 1 1 1
⇐ PC
RI ⇐ DR 1 1 1
PC ⇐ AC+0+c13; 2 1 1 1 1 1 1 1 1
DEC.
AC ⇐ A 3 1 1
B ⇐ B+AC 4 0 1 1 1 1 1 1 0
AC ⇐ A 5 1 1
B ⇐ AC + 0 (cte) 6 0 1 1 1 1 1 0
AC ⇐ A 7 1 1
B ⇐ B+AC 8 0 1 1 1
DR ⇐ (B); AC⇐ 0 9 0 1 1 1 1 1 0
B ⇐ DR+AC 10 0 1 1 1 1 1 0
Si N=1 salta a 0 11 0 1 0
AC⇐ C; Si Z=1 12 1 0 1 1 1 0 0
salta a 0
PC⇐ AC+0 13 1 1 1 1 1 1 0
268
Mem. Reg. Dir. Reg. Dat. Carga ALU Transf. M Salto
Descripción Dir.
c1 c2 c3 c4 c5 c6 c7 c8 c9 c10 c11 c12 c13 c14 c15 c16 c17 c18 CS Dir. Salto
RI ⇐ (PC) 0 1 0 1
TEMPA ⇐ PC 1 1 1
TEMPB ⇐ R1 2 1 1 1 1
PC⇐ALU; DEC. 3 0 0 1 1 1 11
TMP ⇐ [RY] 4 1 1 1 1 1
[RX] ⇐ TMP 5 1 1 1 1 11 0
TEMPA ⇐ [RX] 6 1 1
TEMPB ⇐ [RY] 7 1 1 1
[RX] ⇐ ALU 8 1 1 1 1 11 0
Si C=1 salta a 0 9 01 0
PC ⇐ [RY] 10 1 1 1 11 0
TEMPA ⇐ SI 11 1 1 1
TEMPB ⇐ [RY] 12 1 1 1
TMP ⇐ ALU 13 1 1 1 1
[RX] ⇐ (TMP) 14 1 1 1 1 11 0

269
E.4. SECCIÓN DE PROCESAMIENTO: ALGORITMOS

ARITMÉTICOS
Muchos de los problemas de este tema son autocomprobables, por lo que se

ha omitido su solución.
1. Realizar las siguientes sumas con números de 6 bits: 12+9, 27-15, 14-19,
-7-13, 23+10, -20-13; representando los números mediante los siguientes
convenios:
a) Signo y Magnitud
b) Complemento a 1
c) Complemento a 2
2. Haz con números de 8 bits trabajando en
a) Complemento a 1
b) Complemento a 2
las operaciones siguientes:
00101101 + 01101111
11111111 + 11111111
00000000 − 11111111
11110111 − 11110111
3. Encuentra la razón por la que, en el algoritmo de suma/resta en C1, hay
que sumar el carry de salida al resultado.
Solución:
Para hacer la demostración vamos a ir viendo qué ocurre en cada
uno de los casos posibles:
a) Los dos números a sumar son positivos (x n = yn = 0). Como los
dos bits de signo son cero, cn+1 = 0 siempre. En este caso puede
ocurrir:
1) sn = cn = 0 → situación normal
2) sn = 1, como deberı́a ser cero (suma de positivos es positiva),
nos indica que existe desbordamiento en la suma
b) Los dos números a sumar son de distinto signo. Veremos que ocurre
si x > 0 e y < 0. El otro caso es simétrico, por lo que la demostra-
ción es similar, intercambiando x por y.
C1(x) + C1(y) = ∥x∥ + 2n − 1 − ∥y∥ = 2n − 1 + ∥x∥ − ∥y∥

∥y∥ > ∥x∥ → el resultado es negativo y queremos que esté en
C1, que es lo que tenemos (no aparece acarreo):
C1(y − x) = 2n − 1 − (y − x)
∥x∥ > ∥y∥ → el resultado es positivo, queremos tener x − y y
sin embargo hemos obtenido:
2n − 1 + x − y
Esto se traduce, por un lado, en un uno en la posición del c n+1
(2n ) y en otro uno que aparece restando y que nos sobra. Para
cancelarlos lo que hacemos es sumar el acarreo obtenido con lo
que desaparece el acarreo y se compensa el -1.
c) Los dos números a sumar son negativos (x n = yn = 1). Como los
dos bits de signo son uno, cn+1 = 1 siempre. Si sn = 0 se habrá pro-
ducido overflow, pues no podemos tener un resultado positivo. En
este caso también se debe sumar el acarreo para obtener el resultado
correcto:
C1(x) + C1(y) = 2n − 1 − ∥x∥ + 2n − 1 − ∥y∥

= 2n − 1 + 2n − 1 − (x + y) (E.1)
7 89 :
Solo nos interesará la parte que abarca la llave como resultado. Para
elminar el resto hacemos lo mismo de antes: sumar el acarreo (2 n )
con el -1, con lo que se cancelan.
A modo de conclusión, podemos afirmar que siempre que aparezca un
acarreo habrá que sumarlo al resultado para corregirlo.
4. Los números decimales con signo de n − 1 dı́gitos se pueden representar
mediante n dı́gitos sin signo utilizando la representación en complemento
a 9. El complemento a 9 es el complemento a la base menos 1 cuando
la base es 10 (igual que el C1 es el complemento a la base menos uno
cuando la base es 2). El C9 de un número decimal N se obtiene mediante
la siguiente expresión:
C9(N ) = 10n − 1 − N
donde n es el número de dı́gitos con que trabajo. Una técnica para hacer
el C9 de un número consiste en restar cada dı́gito de 9. Ası́, el negativo
de 014725 es 985274. Se pide:
a) Expresa como números de tres dı́gitos en complemento a 9 los si-
guientes números: 6, -2, 99, -12, -1, 0.
b) Determinar la regla por la cual se suman los números en comple-

mento a 9.
c) Realizar las siguientes sumas con dicha técnica:
1) 0001 + 9999
2) 0001 + 9998
3) 9997 + 9996
4) 9241 + 0802
Solución:
El modo de proceder es como en complemento a uno cuando traba-
jamos en binario (ver apuntes de teorı́a, ya que el complemento a 9 es
otro caso particular del complemento a la base menos uno, en el que la
base es 10).
5. Los números en complemento a 10 son análogos a los números en com-
plemento a 2. Un número negativo en C10 se forma con sólo sumar 1 al
número correspondiente en C9, prescindiendo del acarreo. Más formal-
mente, el C10 de un número decimal N se obtiene mediante la siguiente
expresión:
C10(N ) = 10n − N
¿Cuál será la regla para la adición en complemento a 10?
Solución:
El modo de proceder es como en complemento a dos cuando trabaja-
mos en binario (ver apuntes de teorı́a, ya que el complemento a 10 es
otro caso particular del complemento a la base, en el que la base es 10).
6. Cuando realizamos operaciones de suma/resta en decimal, realmente es-
tamos utilizando un algoritmo de suma/resta para números decimales
representados en signo/magnitud, donde el “dı́gito” de signo esta repre-
sentado por el + o el − que antecede al número. Realiza, con aritmética
decimal de tres dı́gitos más el signo, las siguientes sumas y comprueba
que el algoritmo que debes utilizar es semejante al visto en teorı́a para los
números en binario: (−264)+(−858), (+858)+(−264), (+264)+(−858).
7. Árbol de Wallace
a) Dibujar el árbol de Wallace para sumar 6 números enteros mediante
CSA’s (Carry Save Adders). ¿Cómo ha de ser el último sumador?
b) Sumar 12 + 5 + 7 + 3 + 10 + 9 siguiendo la estructura previa.
Solución:
a) La arquitectura necesaria para implementar el sumador de 6 su-
mandos aparece representada en la figura E.3. El último sumador
es un sumador de acarreo anticipado o propagado (SAP).
12 + 5 + 7 + 3 +10 + 9 = 46
CSA1 CSA2
s1 2·c1 s2 2·c2
CSA3
s3 2·c3
CSA4
s4 2·c4
SAP
SUMA=46
Figura E.3: Árbol de Wallace para seis sumandos
b) En primer lugar sumamos 12+5+7, para conseguir s1 y c1. En pa-

ralelo sumamos 3+10+9 obteniendo s2 y c2; a continuación suma-
mos s1+2c1+s2 seguido de s3+2c3+2c2. Por último en un sumador
convencional sumamos s4+2c4.
001100 x1 000011 x4
000101 x2 001010 x5
000111 x3 001001 x6
--------- ---------
001110 s1 000000 s2
000101 c1 001011 c2
s1 001110
2c1 001010
s2 ------
000100 s3
001010 c3
s3 000100
2c3 010100
2c2 010110
------
000110 s4
010100 c4
s4 000110
2c4 101000
------
101110 = 46
Deberemos usar sumadores de al menos 6 bits (ó siete si trabajamos

en C2) para evitar desbordamiento de la suma.
8. ¿Cuándo tiene sentido utilizar sumadores con acarreo almacenado (CSA)?
Construir el Árbol de Wallace para sumar 7 − 5 + 9 y realizar la suma
utilizando aritmética de 6 bits en C2.
Solución:
Los sumadores de accarreo almacenado son especialmente útiles cuan-
do estamos trabajando con más de dos operandos. En la figura E.4 apa-
rece representado el árbol pedido.
7- 5 + 9
CSA1
SAP
Figura E.4: Árbol de Wallace para tres sumandos
000111 x1
111011 x2
001001 x3
------
110101 s
001011 c
110101 s
010110 2c
------
001011 = 11 (once en decimal)
9. Realiza las siguientes multiplicaciones mediante el algoritmo de multi-
plicación binario de suma y desplazamiento con n=5.
a) 12 × 10
b) 7 × 12
c) 6 × 15
10. Realiza las siguientes divisiones mediante el algoritmo de división binario
con restauración con n=5.
a) 12 ÷ 3
b) 15 ÷ 2
11. Realiza las siguientes operaciones con números en punto flotante en el
formato IEEE 754.
a) C30C0000 + C1500000
b) 3B370000 + 39F 68000
Solución:
a) C30C0000 → 1 | 100 0011 0 | 000 1100 00..00 = −1.00011 × 2 7
C1500000 → 1 | 100 0001 0 | 101 0000 00..00 = −1.101 × 2 3
Igualamos los exponentes al mayor de los dos y sumamos. El resul-

tado obtenido se vuelve a normalizar.
−1.000 1100 × 27
−0.000 1101 × 27
−1.001 1001 × 27
−1.001 1001 × 27 → C3190000

b) 3B370000 → 0 | 011 1101 0 | 011 0111 00..00 = 1.0110111 × 2 −9
39F 68000 → 0 | 011 1001 1 | 111 0110 1000 00..00 = 1.11101101 ×
2−12
1.01101110000 × 2−9
0.00111101101 × 2−9
1.10101011101 × 2−9
1.10101011101 × 2−9 → 3B55D000

Bibliografı́a
[1] A.S.Tanembaum: “Structured Computer Organization”, Cuarta edición,

Prentice-Hall, 1999.
[2] D.A.Patterson, J.L.Hennessy: “Organización de Computadores”, Mc.
Graw-Hill, 1995.
[3] D.A.Patterson, J.L.Hennessy: “Computer Organization & Design. The
hardware/software interface”, Segunda edición. Morgan Kaufmann Pu-
blishers, 1998.
[4] Pedro de Miguel Anasagasti: “Fundamentos de los Computadores”, Pa-
raninfo, Tercera edición, 1992.
[5] A.S.Tanembaum: “Organización de Computadoras”, Segunda Edición,
Prentice-Hall, 1986.
[6] J.P.Hayes: “Computer Architecture and Organization”, Segunda Edicion,
Mc. Graw-Hill, 1988.
[7] P.de Miguel, J.M.Angulo: “Arquitectura de Computadores”, Paraninfo,
1987.
[8] M. Morris Mano: “Arquitectura de Computadores”, Prentice Hall, 1983.
277
Parece que ya deja de sorprender la creciente omnipresencia de los ordena-
dores en todos los ámbitos de la sociedad. A nosotros nos sigue impresionando
la rapidı́sima evolución de los sistemas basados en computador, su creciente
potencia de cálculo capaz de resolver cada vez problemas de mayor compleji-
dad y su capacidad de simplificar y reducir el tiempo necesario para realizar
muchas tareas cotidianas. Pues bien, los fundamentos, conceptos y modos de
operación de estas máquinas tan comunes hoy en dı́a, son los que tratamos
de introducir y desentrañar en este texto. O con otras palabras, este libro
está orientado a aquellas personas que alguna vez se han preguntado “¿Cómo
es posible que los transistores y puertas lógicas que hay dentro de mi ordena-
dor me permitan editar un archivo o ejecutar un programa que he escrito en
Modula o en C?”, pregunta, que por otro lado, esperamos se hayan planteado
todos nuestros alumnos de asignaturas de introducción a los computadores.
Aunque no son del todo necesarios, suponemos que el lector tiene algunos
conocimientos de electrónica digital y programación. Pues bién, en este libro
precisamente queremos cubrir el desnivel semántico que existe en un sistema
computador entre esas dos materias (electrónica digital y lenguajes de alto
nivel), contemplando el control microprogramado y cableado, el lenguaje en-
samblador y los sistemas operativos, según desglosamos a continuación por
temas.
El tema 1 introduce los primeros conceptos básicos y una descripción ini-
cial de la arquitectura de von Neumann. El tema 2 describe los convenios
comúnmente utilizados para representar números, caracteres e instrucciones
en el computador. A partir del tema 3 profundizamos en la arquitectura de
computadores siguiendo un esquema estructural, en el que el computador se
compone del procesador (tema 3), el cual engloba la sección de control (tema
4) y de procesamiento (tema 5), jerarquı́a de memoria (tema 6) y unidad de
Entrada/Salida (tema 7). Por último, el tema 8 describe como los Sistemas
Operativos permiten gestionar toda la arquitectura, dando una visión global
del computador.

MAN30 Fundamentos Computadores PDF

Cargado por

Copyright:

Formatos disponibles

MAN30 Fundamentos Computadores PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

MAN30 Fundamentos Computadores PDF

Cargado por

Copyright:

Formatos disponibles

RAFAEL ASENJO PLAZA

ELADIO GUTIÉRREZ CARRASCO

UNIVERSIDAD DE MALAGA / MANUALES

Fundamentos de los Computadores

Rafael Asenjo Plaza

Diseño de Ia colección: J. M. Mercado

Imprime: Imagraf Impresores, S.A. Tel.: 952 32 85 97

Esta obra está bajo una licencia de Creative Commons

Este material ha sido preparado por:

c Esta obra está bajo una Licencia Creative Commons Atribución-NoComercial-

b Debe dar crédito en la obra en la forma especificada por el autor o

e El licenciante permite copiar, distribuir y comunicar publicamente la

d El licenciante permite copiar, distribuir, transmitir y comunicar públi-

Índice de Tablas XII

1.- Introducción a los Computadores 1

2.- Representación de la Información 13

2.3.5. Códigos de operación . . . . . . . . . . . . . . . . . . . . 33

3.- Procesador Central 39

4.- Sección de Control 71

4.4. Diseño de una unidad de control cableada . . . . . . . . . . . . 103

5.- Sección de Procesamiento 141

6.- Memorias 167

7.- Entrada/Salida 181

8.- Introducción a los Sistemas Operativos 193

A. Sistemas de representación especiales 209

B. Rendimiento de un computador 215

B.2. Observación de Moore . . . . . . . . . . . . . . . . . . . . . . . 218

C. Códigos completos para el i8086 223

D. Detalles de diseño de cache 229

E. Solución a las relaciones de problemas 249

1.1. Máquina de Charles Babbage . . . . . . . . . . . . . . . . . . . 4

4.21. Contador de secuencias módulo k . . . . . . . . . . . . . . . . . 111

8.2. S.O. Multitarea . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

A.1. Arbol de generación Huﬀman . . . . . . . . . . . . . . . . . . . 212

B.1. Casos Lı́mite de la Ley de Amdahl. . . . . . . . . . . . . . . . . 218

D.1. Asignación directa . . . . . . . . . . . . . . . . . . . . . . . . . 230

E.1. Diagrama de Flujo del programa del problema 8 . . . . . . . . 261

2.1. Código de caracteres ASCII en octal . . . . . . . . . . . . . . . 27

5.2. Operación a realizar en el algoritmo bit-scanning . . . . . . . . 158

E.1. Contenido de la memoria . . . . . . . . . . . . . . . . . . . . . 263

Parece que ya deja de sorprender la creciente omnipresencia de los ordena-

4) y de procesamiento (tema 5), jerarquı́a de memoria (tema 6) y unidad de

terés para completar conocimientos de arquitectura y otras noticias, como

Describir las caracterı́sticas básicas de los computadores del tipo von

1.1. NATURALEZA DE LOS COMPUTADORES

Empecemos esta introducción a la arquitectura de computadores recordando

1.2. ANTECEDENTES HISTÓRICOS

1.2.1. Progresos mecánicos

• intuye que la máquina trabajará mejor con números binarios. (Esta

The Mill The Store

Figura 1.1: Máquina de Charles Babbage

En 1880, Herman Holleritz, crea una máquina capaz de hacer estadı́sticas

1.2.2. Progresos electromecánicos. Relés

trabaja con números complejos, para realizar cálculos balı́sticos. Fue el

1.2.3. Progresos electrónicos

1.3. ARQUITECTURA DE VON NEUMANN

La mayorı́a de los computadores se han construido siguiendo la arquitectura

Entrada ALU Salida

Figura 1.2: Máquina de von Neumann