INSTITUTO TECNOLÓGICO DE ORIZABA

PROFESOR: MARCO ANTONIO VÁZQUEZ ROMERO

MATERIA: ARQUITECTURA DE COMPUTADORAS

TAREA: CRESTOMATÍA DE LA UNIDAD 2°

ESTRUCTURA Y FUNCIONAMIENTO DE LA CPU

ALUMNOS: JESÚS JAVIER REYES GAONA

ALEXIS LEONEL MONROY RODRÍGUE
ENRIQUE ALEXIS ROBLES GONZALEZ

FECHA DE ENTREGAR 26-09-2019

Contenido
Introducion.................................................................................................................2
Organización del procesador.....................................................................................3
Estructura de registros...............................................................................................3
Registros visibles para el usuario..............................................................................3
Registros de control y de estados.............................................................................4
Ejemplos de organización de registros de CPU reales.............................................5
Ciclo Fetch-Decode-Execute.....................................................................................5
Conjunto de instrucciones: Características y funciones............................................6
Modos de direccionamiento y formatos.....................................................................7
Estructura de registro................................................................................................7
Ejemplo: Creación de un registro (o estructura) en C...............................................7
Registro en bases de datos.......................................................................................8
Registros....................................................................................................................8
Declaración Un registro se declara de la siguiente manera:.....................................8
Operaciones...............................................................................................................9
Pase de parámetros................................................................................................10
Archivos...................................................................................................................13
Declaración..............................................................................................................13
ORGANIZACIÓN DE LA UNIDAD CENTRAL DE PROCESO (CPU)....................17
Componentes Básicos de la CPU...........................................................................17
Ciclo de Instrucción.................................................................................................20
Estructura de la CPU...............................................................................................21
Estructuras de Interconexión...................................................................................30
Conjunto de instrucciones.......................................................................................31
El lenguaje máquina................................................................................................32
Implementación del conjunto de instrucciones........................................................34
Densidad del código................................................................................................35
Número de operando...............................................................................................36
Características deseables.......................................................................................37
Tipos de instrucciones y ejemplos...........................................................................38
Instrucciones aritméticas.........................................................................................39
Instrucciones de comparación.................................................................................39
Instrucciones lógicas........................................................................................39
Instrucciones de desplazamiento.....................................................................40
Instrucciones de bits.........................................................................................40
Instrucciones de control....................................................................................40
Instrucciones de entrada y salida.....................................................................41
Instrucciones de control y misceláneas...........................................................41
Segmentación de instrucciones...............................................................................42
Número de pasos.....................................................................................................43
Peligros....................................................................................................................44
Medidas cautelares..................................................................................................44
Soluciones...............................................................................................................45
Ramas......................................................................................................................45
Programas auto-modificables..................................................................................46
Instrucciones no interrumpibles...............................................................................46
Consideraciones de diseño.....................................................................................47
Ejemplo ilustrado.....................................................................................................48
Burbuja en la segmentación....................................................................................50
Ciclo de instrucción..................................................................................................52
Secuencia de acciones del ciclo de instrucción......................................................52
1. Buscar la instrucción en la memoria principal..................................................52
2. Decodificar la instrucción..................................................................................53
3. Ejecutar la instrucción..........................................................................................53
4. Almacenar o guardar resultados.........................................................................53
Estructuras de Interconexión...................................................................................57
ESTRUCTURA DE BUS......................................................................................58
Funcionamiento de la Unidad Central de Proceso..................................................60
Estructura del Procesador.......................................................................................64
Organización de Registros......................................................................................65
Unidad Aritmético Lógica.........................................................................................67
Conjunto de Instrucciones.......................................................................................68
Elementos de una instrucción maquina...................................................................69
Tipos de operación..................................................................................................70
Direccionamiento.....................................................................................................70
1.8. Operación de la Unidad de Control..................................................................73
Control de la CPU................................................................................................76
Control microprogramado....................................................................................77
Unidad de control microprogramada....................................................................81
1.10. Estructura segmentada...................................................................................84
Registro de control y estado....................................................................................88
El ciclo de instrucción..............................................................................................91
Modos de Direccionamiento....................................................................................94
EL CICLO DE INSTRUCCIÓN................................................................................96
Un ciclo de instrucción incluye los siguientes subciclos:........................................96
El Ciclo Indirecto......................................................................................................97
Ciclo de instrucción:.................................................................................................98
Ciclo de ejecución:...................................................................................................99
EJEMPLOS DE CILOS EN MAQUINAS...............................................................100
CONJUNTO DE INSTRUCCIONES......................................................................100
Características generales de los conjuntos de instrucciones...............................101
Tipos de instrucciones...........................................................................................102
Instrucciones de transferencia de datos................................................................102
Instrucciones aritméticas y lógicas........................................................................103
Instrucciones de control del flujo de programa......................................................108
Iteracione...............................................................................................................113
Procedimiento........................................................................................................114
Corrutinas..............................................................................................................117
Desvíos o excepciones (traps)..............................................................................118
Interrupciones........................................................................................................119
Instrucciones de control de flujo en el VAX...........................................................119
Modos de direccionamiento y formatos.................................................................130
B) Forma de almacenar operandos en la CPU.....................................................133
Códigos de operación de longitud fija y variable...................................................133
Optimización del CO variable en función de la frecuencia de las instrucciones...135
Propiedades generales del direccionamiento.......................................................136
Espacios de direcciones........................................................................................138
Modos de direccionamiento...................................................................................138

Ilustración 1 ejemplo creacion de un regristro en C................................................13

Ilustración 2 tabla de declaracion registro...............................................................14
Ilustración 3 ejemplo se declara un registro y luego variables de ese tipo de
registro.....................................................................................................................14
Ilustración 4 registro y las vaiables..........................................................................15
Ilustración 5 pase de parámetros............................................................................15
Ilustración 6 Este algoritmo permite definir un arreglo del tipo carta......................17
Ilustración 7 declaracion..........................................................................................18
Ilustración 8 Ejemplo de abrir archivos....................................................................19
Ilustración 9 lectura de un archivo caracter por caracter (asumiendo que el archivo
está abierto y es de lectura)....................................................................................19
Ilustración 10 escritura en un archivo (asumiendo que el archivo está abierto y es
de escritura).............................................................................................................19
Ilustración 11 ejemplo permite leer la información almacenada en un archivo
“info.dat”...................................................................................................................20
Ilustración 12 ejemplo permite crear un archivo e ingresar la información en un
archivo “info.dat”......................................................................................................21
Ilustración 13 Inventario...........................................................................................21
Ilustración 14 instruction registro (IR)......................................................................25
Ilustración 15 diagrama se muestra la estructura de una CPU..............................27
Ilustración 16 Ejecucion reloj...................................................................................54
Ilustración 17 Segmentación genérica de 4 etapas................................................55
Ilustración 18 Una burbuja en el ciclo 3 retarda la ejecución..................................56
Ilustración 19 ciclo de instrucciones........................................................................97
Ilustración 20 analisis de un bit.............................................................................109
Ilustración 21Puesta 0 de un bit............................................................................109
Ilustración 22Puesta 1 de un bit............................................................................110
Ilustración 23Complemento de un bit....................................................................110
Ilustración 24 Empaquetamiento de caracteres....................................................112
Ilustración 25 Desempaquetamiento de caracteres..............................................113
Ilustración 26Secuencia lineal de ejecución de instrucciones..............................114
Ilustración 27Secuencia con puntos de discontinuidad en la ejecución de
instrucciones..........................................................................................................114
Ilustración 28Bifurcación condicional....................................................................115
Ilustración 29 Tabla de verdad de la suma para el bit de signo............................116
Ilustración 30Trama de pila de dos procedimientos anidados..............................121
Ilustración 31Flujo de instrucciones en una llamada a procedimiento (a) y entre
corrutinas (b)..........................................................................................................122
Ilustración 32 Corrutinas........................................................................................122
Ilustración 33 Instrucciones de bifurcación condicional en el VAX......................125
Ilustración 34 Instrucciones para el control de iteraciones del VAX.....................127
Ilustración 35 Lista de argumentos de un procedimiento en un VAX...................128
Ilustración 36 Trama de pila de un procedimiento en el VAX...............................129
Ilustración 37 Tipo de dirrecionamiento.................................................................136
Ilustración 38 Ejemplo...........................................................................................137
Ilustración 39 Ejemplo2.........................................................................................138
Ilustración 40 Ejemplo 3........................................................................................139
Ilustración 41Tipo de instruciones y frecuencia de ejecución...............................140
Ilustración 42 Codigo de Huffman.........................................................................141
Ilustración 43Resolucion........................................................................................141
Ilustración 44Modos...............................................................................................142
Ilustración 45 Direccion de un registro..................................................................145
Ilustración 46 Dirrecionamiento base mas desplazamiento..................................145
Ilustración 47Resumen tipos de direccionamiento................................................146
 Introducción
La expresión "unidad central de proceso" es, en términos generales, una
descripción de una cierta clase de máquinas de lógica que pueden ejecutar
complejos programas de computadora. Esta amplia definición puede fácilmente
ser aplicada a muchos de los primeros computadores que existieron mucho antes
que el término "CPU" estuviera en amplio uso. Sin embargo, el término en sí
mismo y su acrónimo han estado en uso en la industria de la informática por lo
menos desde el principio de los años 1960.

La CPU también es la llamada unidad central de procesamiento (por el acrónimo

en inglés de central processing unit), o simplemente el procesador o
microprocesador, es el componente del computador y otros dispositivos
programables, que interpreta las instrucciones contenidas en los programas y
procesa los datos. Los CPU proporcionan la característica fundamental de la
computadora digital (la programabilidad) y son uno de los componentes
necesarios encontrados en las computadoras de cualquier tiempo, junto con el
almacenamiento primario y los dispositivos de entrada/salida. Se conoce como
microprocesador el CPU que es manufacturado con circuitos integrados.

La forma, el diseño y la implementación de los CPU ha cambiado drásticamente

desde los primeros ejemplos, pero su operación fundamental ha permanecido
bastante similar.
Historia

Los primeros ordenadores, como el ENIAC, tenían que ser físicamente

recableados para realizar diferentes tareas, lo que hizo que estas máquinas se
denominaran "ordenadores de programa fijo". Dado que el término "CPU"
generalmente se define como un dispositivo para la ejecución de software
(programa informático), los primeros dispositivos que con razón podríamos llamar
CPU vinieron con el advenimiento del ordenador con programa almacenado.

La idea de un ordenador con programa almacenado ya estaba presente en el

diseño de John Presper Eckert y en el ENIAC de John William Mauchly, pero esta
característica se omitió inicialmente para que el aparato pudiera estar listo antes.
El 30 de junio de 1945, antes de que se construyera la ENIAC, el matemático John
von Neumann distribuyó el trabajo titulado First Draft of a Report on the EDVAC
(Primer Borrador de un Reporte sobre el EDVAC). Fue el esbozo de un ordenador
de programa almacenado, que se terminó en agosto de 1949.2 EDVAC fue
diseñado para realizar un cierto número de instrucciones (u operaciones) de varios
tipos. Significativamente, los programas escritos para el EDVAC se crearon para
ser almacenados en la memoria de alta velocidad del ordenador y no para que los
especificara el cableado físico del ordenador. Esto superó una severa limitación
del ENIAC, que era el importante tiempo y esfuerzo requerido para volver a
configurar el equipo para realizar una nueva tarea. Con el diseño de von
Neumann, el programa o software que corría EDVAC podría ser cambiado
simplemente cambiando el contenido de la memoria. Sin embargo, EDVAC no fue
el primer ordenador de programa almacenado, la Máquina Experimental de
Pequeña Escala de Mánchester, un pequeño prototipo de ordenador de programa
almacenado, ejecutó su primer programa el 21 de junio de 1948.3 Su sucesora, la
Manchester Mark I, ejecutó su primer programa en la noche del 16 al 17 junio de
1949.

Las primeras CPU fueron diseñadas a medida como parte de un ordenador más
grande, generalmente un ordenador único en su especie. Sin embargo, este
método de diseñar las CPU a medida, para una aplicación particular, ha
desaparecido en gran parte y se ha sustituido por el desarrollo de clases de
procesadores baratos y estandarizados adaptados para uno o varios propósitos.
Esta tendencia de estandarización comenzó generalmente en la era de los
transistores discretos, computadoras centrales y microcomputadoras y fue
acelerada rápidamente con la popularización del circuito integrado (IC), este ha
permitido que sean diseñados y fabricados CPU más complejas en espacios
pequeños en la orden de nanómetros. Tanto la miniaturización como la
estandarización de las CPU han aumentado la presencia de estos dispositivos
digitales en la vida moderna mucho más allá de las aplicaciones limitadas de
máquinas de computación dedicadas. Los microprocesadores modernos aparecen
en todo, desde automóviles hasta teléfonos móviles o celulares y juguetes de
niños.

Si bien von Neumann muchas veces acreditado por el diseño de la computadora

con programa almacenado debido a su diseño del EDVAC, otros antes que él,
como Konrad Zuse, habían sugerido y aplicado ideas similares. La denominada
arquitectura Harvard del Harvard Mark I, que se completó antes de EDVAC,
también utilizó un diseño de programa almacenado usando cinta de papel
perforada en vez de memoria electrónica. La diferencia clave entre las
arquitecturas de von Neumann y la de Harvard es que la última separa el
almacenamiento y tratamiento de instrucciones de la CPU y los datos, mientras
que el primero utiliza el mismo espacio de memoria para ambos. La mayoría de
los CPU modernos son de diseño von Neumann, pero los CPU con arquitectura
Harvard se ven así, sobre todo en aplicaciones embebidas; por ejemplo, los
microcontroladores Atmel AVR son procesadores de arquitectura Harvard.

Los relés eléctricos y los tubos de vacío (válvulas termoiónicas) eran usados
comúnmente como elementos de conmutación; un ordenador útil requiere miles o
decenas de miles de dispositivos de conmutación. La velocidad global de un
sistema depende de la velocidad de los conmutadores. Los ordenadores de tubo,
como el EDVAC, tendieron en tener un promedio de ocho horas entre fallos,
mientras que los ordenadores de relés, (anteriores y más lentos), como el Harvard
Mark I, fallaban muy raramente.1 Al final, los CPU basados en tubo llegaron a ser
dominantes porque las significativas ventajas de velocidad producidas
generalmente pesaban más que los problemas de confiabilidad. La mayor parte de
estas tempranas CPU síncronas corrían en frecuencias de reloj bajas comparadas
con los modernos diseños microelectrónicos. Eran muy comunes en este tiempo
las frecuencias de la señal del reloj con un rango desde 100 kHz hasta 4 MHz,
limitado en gran parte por la velocidad de los dispositivos de conmutación con los
que fueron construidos.
La complejidad del diseño de las CPU aumentó junto con la facilidad de la
construcción de dispositivos electrónicos más pequeños y confiables. La primera
de esas mejoras vino con el advenimiento del transistor. Las CPU transistorizadas
durante los años 1950 y los años 1960 no tuvieron que ser construidos con
elementos de conmutación abultados, no fiables y frágiles, como los tubos de
vacío y los relés eléctricos. Con esta mejora, fueron construidas CPU más
complejas y más confiables sobre una o varias tarjetas de circuito impreso que
contenían componentes discretos (individuales).

Durante este período, ganó popularidad un método de fabricar muchos

transistores en un espacio compacto. El circuito integrado (IC) permitió que una
gran cantidad de transistores fueran fabricados en una simple oblea basada en
semiconductor o "chip". Al principio, solamente circuitos digitales muy básicos, no
especializados, como las puertas NOR fueron miniaturizados en IC. Las CPU
basadas en estos IC de "bloques de construcción" generalmente son referidos
como dispositivos de pequeña escala de integración "small-scale integration"
(SSI). Los circuitos integrados SSI, como los usados en el computador guía del
Apollo (Apollo Guidance Computer), usualmente contenían transistores que se
contaban en números de múltiplos de diez. Construir un CPU completo usando IC
SSI requería miles de chips individuales, pero todavía consumía mucho menos
espacio y energía que diseños anteriores de transistores discretos. A medida que
la tecnología microelectrónica avanzó, en los IC fue colocado un número creciente
de transistores, disminuyendo así la cantidad de IC individuales necesarios para
una CPU completa. Los circuitos integrados MSI y el LSI (de mediana y gran
escala de integración) aumentaron el número de transistores a cientos y luego a
miles.

En 1964, IBM introdujo su arquitectura de ordenador System/360, que fue usada

en una serie de ordenadores que podían ejecutar los mismos programas con
velocidades y desempeños diferentes. Esto fue significativo en un tiempo en que
la mayoría de los ordenadores electrónicos eran incompatibles entre sí, incluso las
hechas por el mismo fabricante. Para facilitar esta mejora, IBM utilizó el concepto
de microprograma, a menudo llamado «microcódigo», ampliamente usado aún en
las CPU modernas.4 La arquitectura System/360 era tan popular que dominó el
mercado del mainframe durante las siguientes décadas y dejó una herencia que
todavía aún perdura en los ordenadores modernos, como el IBM zSeries. En el
mismo año de 1964, Digital Equipment Corporation (DEC) introdujo otro ordenador
que sería muy influyente, dirigido a los mercados científicos y de investigación, el
PDP-8. DEC introduciría más adelante la muy popular línea del PDP-11, que
originalmente fue construido con IC SSI pero eventualmente fue implementado
con componentes LSI cuando se convirtieron en prácticos. En fuerte contraste con
sus precursores hechos con tecnología SSI y MSI, la primera implementación LSI
del PDP-11 contenía una CPU integrada únicamente por cuatro circuitos
integrados LSI.5

Los ordenadores basados en transistores tenían varias ventajas frente a sus

predecesores. Aparte de facilitar una creciente fiabilidad y un menor consumo de
energía, los transistores también permitían que CPU operara a velocidades mucho
más altas debido al corto tiempo de conmutación de un transistor en comparación
a un tubo o relé. Gracias tanto a esta creciente fiabilidad como al dramático
incremento de velocidad de los elementos de conmutación que por este tiempo
eran casi exclusivamente transistores, se fueron alcanzando frecuencias de reloj
de la CPU de decenas de megahercios. Además, mientras que las CPU de
transistores discretos y circuitos integrados se usaban comúnmente, comenzaron
a aparecer los nuevos diseños de alto rendimiento como procesadores vectoriales
SIMD (single instruction multiple data – instrucción única, datos múltiples). Estos
primeros diseños experimentales dieron lugar más adelante a la era de los
superordenadores especializados, como los hechos por Cray Inc.
En la década de 1970 los inventos fundamentales de Federico Faggin (ICs Silicon
Gate MOS con puertas autoalineadas junto con su nueva metodología de diseño
de lógica aleatoria) cambió el diseño e implementación de las CPU para siempre.
Desde la introducción del primer microprocesador comercialmente disponible, el
Intel 4004, en 1970 y del primer microprocesador ampliamente usado, el Intel
8080, en 1974, esta clase de CPU ha desplazado casi totalmente el resto de los
métodos de implementación de la Unidad Central de procesamiento. Los
fabricantes de mainframes y miniordenadores de ese tiempo lanzaron programas
de desarrollo de IC propietarios para actualizar sus arquitecturas de computadoras
más viejas y eventualmente producir microprocesadores con conjuntos de
instrucciones que eran retrocompatibles con sus hardwares y softwares más
viejos. Combinado con el advenimiento y el eventual vasto éxito de la ahora
ubicua computadora personal, el término "CPU" es aplicado ahora casi
exclusivamentenota 1 a los microprocesadores.

Las generaciones previas de CPU fueron implementadas como componentes

discretos y numerosos circuitos integrados de pequeña escala de integración en
una o más tarjetas de circuitos. Por otro lado, los microprocesadores son CPU
fabricados con un número muy pequeño de IC; usualmente solo uno. El tamaño
más pequeño del CPU, como resultado de estar implementado en una simple
pastilla, significa tiempos de conmutación más rápidos debido a factores físicos
como el decrecimiento de la capacitancia parásita de las puertas. Esto ha
permitido que los microprocesadores síncronos tengan tiempos de reloj con un
rango de decenas de megahercios a varios gigahercios. Adicionalmente, como ha
aumentado la capacidad de construir transistores excesivamente pequeños en un
IC, la complejidad y el número de transistores en un simple CPU también se ha
incrementado dramáticamente. Esta tendencia ampliamente observada es descrita
por la ley de Moore, que ha demostrado hasta la fecha, ser una predicción
bastante exacta del crecimiento de la complejidad de los CPUs y otros IC.6
Mientras que, en los pasados sesenta años han cambiado drásticamente, la
complejidad, el tamaño, la construcción y la forma general de la CPU, es notable
que el diseño y el funcionamiento básico no ha cambiado demasiado. Casi todos
los CPU comunes de hoy se pueden describir con precisión como máquinas de
programa almacenado de von Neumann.nota 2 A medida que la ya mencionada
ley del Moore continúa manteniéndose verdadera,6 se han presentado
preocupaciones sobre los límites de la tecnología de transistor del circuito
integrado. La miniaturización extrema de puertas electrónicas está causando los
efectos de fenómenos que se vuelven mucho más significativos, como la
electromigración y el subumbral de pérdida. Estas nuevas preocupaciones están
entre los muchos factores que hacen a investigadores estudiar nuevos métodos de
computación como la computación cuántica, así como ampliar el uso de
paralelismo y otros métodos que extienden la utilidad del modelo clásico de von
Neumann.
La operación fundamental de la mayoría de las CPU es ejecutar una secuencia de
instrucciones almacenadas llamadas «programa». El programa es representado
por una serie de números que se mantienen en una cierta clase de memoria de
ordenador. Hay cuatro pasos que casi todos las CPU de arquitectura de von
Neumann usan en su operación: fetch, decode, execute, y writeback, (leer,
decodificar, ejecutar y escribir).
Fetch
El primer paso, leer, implica el recuperar una instrucción, (que es representada por
un número o una secuencia de números), de la memoria de programa. La
localización en la memoria del programa es determinada por un contador de
programa (PC), que almacena un número que identifica la dirección de la siguiente
instrucción que se debe buscar. Después se lee una instrucción, el PC es
incrementado por la longitud de la instrucción en términos de unidades de
memoria de modo que contendrá la dirección de la siguiente instrucción en la
secuencia.nota 3 Frecuentemente, la instrucción a ser leída debe ser recuperada
de memoria relativamente lenta, haciendo detener al CPU mientras espera que la
instrucción sea devuelta. Esta cuestión se trata en gran medida en los
procesadores modernos por los cachés y las arquitecturas pipeline (ver abajo).

Decode
En el paso de decodificación, la instrucción es dividida en partes que tienen
significado para otras unidades de la CPU. La manera en que el valor de la
instrucción numérica es interpretado está definida por la arquitectura del conjunto
de instrucciones (el ISA) de la CPU.nota 4 A menudo, un grupo de números en la
instrucción, llamados opcode, indica qué operación realizar. Las partes restantes
del número usualmente proporcionan información requerida para esa instrucción,
como por ejemplo, operandos para una operación de adición. Tales operandos se
pueden dar como un valor constante (llamado valor inmediato), o como un lugar
para localizar un valor, que según lo determinado por algún modo de dirección,
puede ser un registro o una dirección de memoria. En diseños más viejos las
unidades del CPU responsables de decodificar la instrucción eran dispositivos de
hardware fijos. Sin embargo, en CPUs e ISAs más abstractos y complicados, es
frecuentemente usado un microprograma para ayudar a traducir instrucciones en
varias señales de configuración para el CPU. Este microprograma es a veces
reescribible de tal manera que puede ser modificado para cambiar la manera en
que el CPU decodifica instrucciones incluso después de que haya sido fabricado.

Execute

Diagrama de bloques de un CPU simple.

Después de los pasos de lectura y decodificación, es llevado a cabo el paso de la
ejecución de la instrucción. Durante este paso, varias unidades del CPU son
conectadas de tal manera que ellas pueden realizar la operación deseada. Si, por
ejemplo, una operación de adición fue solicitada, una unidad aritmético lógica
(ALU) será conectada a un conjunto de entradas y un conjunto de salidas. Las
entradas proporcionan los números a ser sumados, y las salidas contendrán la
suma final. La ALU contiene la circuitería para realizar operaciones simples de
aritmética y lógica en las entradas, como adición y operaciones de bits (bitwise). Si
la operación de adición produce un resultado demasiado grande para poder ser
manejado por el CPU, también puede ser ajustada una bandera (flag) de
desbordamiento aritmético localizada en un registro de banderas (ver abajo la
sección sobre rango de números enteros).

Writeback
El paso final, la escritura, simplemente «escribe» los resultados del paso de
ejecución a una cierta forma de memoria. Muy a menudo, los resultados son
escritos a algún registro interno del CPU para acceso rápido por subsecuentes
instrucciones. En otros casos los resultados pueden ser escritos a una memoria
principal más lenta pero más barata y más grande. Algunos tipos de instrucciones
manipulan el contador de programa en lugar de directamente producir datos de
resultado. Estas son llamadas generalmente "saltos" (jumps) y facilitan
comportamientos como bucles, la ejecución condicional de programas (con el uso
de saltos condicionales), y funciones en programas.nota 5 Muchas instrucciones
también cambiarán el estado de dígitos en un registro de "banderas". Estas
banderas pueden ser usadas para influenciar cómo se comporta un programa,
puesto que a menudo indican el resultado de varias operaciones. Por ejemplo, un
tipo de instrucción de "comparación" considera dos valores y fija un número, en el
registro de banderas, de acuerdo a cuál es el mayor. Entonces, esta bandera
puede ser usada por una posterior instrucción de salto para determinar el flujo de
programa.

Después de la ejecución de la instrucción y la escritura de los datos resultantes, el

proceso entero se repite con el siguiente ciclo de instrucción, normalmente
leyendo la siguiente instrucción en secuencia debido al valor incrementado en el
contador de programa. Si la instrucción completada era un salto, el contador de
programa será modificado para contener la dirección de la instrucción a la cual se
saltó, y la ejecución del programa continúa normalmente. En CPUs más complejos
que el descrito aquí, múltiples instrucciones pueden ser leídas, decodificadas, y
ejecutadas simultáneamente. Esta sección describe lo que es referido
generalmente como el "entubado RISC clásico" (Classic RISC pipeline), que de
hecho es bastante común entre los CPU simples usados en muchos dispositivos
electrónicos, a menudo llamados microcontroladores.

La manera en que un CPU representa los números es una opción de diseño que
afecta las más básicas formas en que el dispositivo funciona. Algunas de las
primeras calculadoras digitales usaron, para representar números internamente,
un modelo eléctrico del sistema de numeración decimal común (base diez).
Algunas otras computadoras han usado sistemas de numeración más exóticos
como el ternario (base tres). Casi todos los CPU modernos representan los
números en forma binaria, en donde cada dígito es representado por una cierta
cantidad física de dos valores, como un voltaje "alto" o "bajo".nota 7

Microprocesador MOS 6502 en un dual in-line package (encapsulado en doble

línea), un diseño extremadamente popular de 8 bits.
Con la representación numérica están relacionados el tamaño y la precisión de los
números que un CPU puede representar. En el caso de un CPU binario, un bit se
refiere a una posición significativa en los números con que trabaja un CPU. El
número de bits (o de posiciones numéricas, o dígitos) que un CPU usa para
representar los números, a menudo se llama "tamaño de la palabra", "ancho de
bits", "ancho de ruta de datos", o "precisión del número entero" cuando se ocupa
estrictamente de números enteros (en oposición a números de coma flotante).
Este número difiere entre las arquitecturas, y a menudo dentro de diferentes
unidades del mismo CPU. Por ejemplo, un CPU de 8 bits maneja un rango de
números que pueden ser representados por ocho dígitos binarios, cada dígito
teniendo dos valores posibles, y en combinación los 8 bits teniendo 28 o 256
números discretos. En efecto, el tamaño del número entero fija un límite de
hardware en el rango de números enteros que el software corre y que el CPU
puede usar directamente.nota 8

El rango del número entero también puede afectar el número de posiciones en

memoria que el CPU puede direccionar (localizar). Por ejemplo, si un CPU binario
utiliza 32 bits para representar una dirección de memoria, y cada dirección de
memoria representa a un octeto (8 bits), la cantidad máxima de memoria que el
CPU puede direccionar es 232 octetos, o 4 GB. Esta es una vista muy simple del
espacio de dirección del CPU, y muchos diseños modernos usan métodos de
dirección mucho más complejos como paginación para localizar más memoria que
su rango entero permitiría con un espacio de dirección plano.

Niveles más altos del rango de números enteros requieren más estructuras para
manejar los dígitos adicionales, y por lo tanto, más complejidad, tamaño, uso de
energía, y generalmente costo. Por ello, no es del todo infrecuente, ver
microcontroladores de 4 y 8 bits usados en aplicaciones modernas, aun cuando
están disponibles CPU con un rango mucho más alto (de 16, 32, 64, e incluso 128
bits). Los microcontroladores más simples son generalmente más baratos, usan
menos energía, y por lo tanto disipan menos calor. Todo esto pueden ser
consideraciones de diseño importantes para los dispositivos electrónicos. Sin
embargo, en aplicaciones del extremo alto, los beneficios producidos por el rango
adicional, (más a menudo el espacio de dirección adicional), son más significativos
y con frecuencia afectan las opciones del diseño. Para ganar algunas de las
ventajas proporcionadas por las longitudes de bits tanto más bajas, como más
altas, muchas CPUs están diseñadas con anchos de bit diferentes para diferentes
unidades del dispositivo. Por ejemplo, el IBM System/370 usó un CPU que fue
sobre todo de 32 bits, pero usó precisión de 128 bits dentro de sus unidades de
coma flotante para facilitar mayor exactitud y rango de números de coma flotante.4
Muchos diseños posteriores de CPU usan una mezcla de ancho de bits similar,
especialmente cuando el procesador está diseñado para usos de propósito
general donde se requiere un razonable equilibrio entre la capacidad de números
enteros y de coma flotante.

Frecuencia de reloj
Artículo principal: Frecuencia de reloj
La mayoría de los CPU, y de hecho, la mayoría de los dispositivos de lógica
secuencial, son de naturaleza síncrona.nota 9 Es decir, están diseñados y operan
en función de una señal de sincronización. Esta señal, conocida como señal de
reloj, usualmente toma la forma de una onda cuadrada periódica. Calculando el
tiempo máximo en que las señales eléctricas pueden moverse en las varias
bifurcaciones de los muchos circuitos de un CPU, los diseñadores pueden
seleccionar un período apropiado para la señal del reloj.

Este período debe ser más largo que la cantidad de tiempo que toma a una señal
moverse, o propagarse en el peor de los casos. Al fijar el período del reloj a un
valor bastante mayor sobre el retardo de la propagación del peor caso, es posible
diseñar todo el CPU y la manera que mueve los datos alrededor de los "bordes"
de la subida y bajada de la señal del reloj. Esto tiene la ventaja de simplificar el
CPU significativamente, tanto en una perspectiva de diseño, como en una
perspectiva de cantidad de componentes. Sin embargo, esto también tiene la
desventaja que todo el CPU debe esperar por sus elementos más lentos, aun
cuando algunas unidades de la misma son mucho más rápidas. Esta limitación ha
sido compensada en gran parte por varios métodos de aumentar el paralelismo del
CPU (ver abajo).

Sin embargo, las mejoras arquitectónicas por sí solas, no solucionan todas las
desventajas de CPUs globalmente síncronas. Por ejemplo, una señal de reloj está
sujeta a los retardos de cualquier otra señal eléctrica. Velocidades de reloj más
altas en CPUs cada vez más complejas hacen más difícil de mantener la señal del
reloj en fase (sincronizada) a través de toda la unidad. Esto ha conducido que
muchos CPU modernos requieran que se les proporcione múltiples señales de
reloj idénticas, para evitar retardar una sola señal lo suficiente como para hacer al
CPU funcionar incorrectamente. Otro importante problema cuando la velocidad del
reloj aumenta dramáticamente, es la cantidad de calor que es disipado por el CPU.
La señal del reloj cambia constantemente, provocando la conmutación de muchos
componentes (cambio de estado) sin importar si están siendo usados en ese
momento. En general, un componente que está cambiando de estado, usa más
energía que un elemento en un estado estático. Por lo tanto, a medida que la
velocidad del reloj aumenta, así lo hace también la disipación de calor, causando
que el CPU requiera soluciones de enfriamiento más efectivas.

Un método de tratar la conmutación de componentes innecesarios se llama el

clock gating, que implica apagar la señal del reloj a los componentes innecesarios,
efectivamente desactivándolos. Sin embargo, esto es frecuentemente considerado
como difícil de implementar y por lo tanto no ve uso común fuera de diseños de
muy baja potencia. Un notable diseño de CPU tardío que utiliza una amplia
compuerta del reloj para reducir los requisitos de potencia de la consola de
videojuegos es la de la Xbox 360 basada en la PowerPC de IBM.7 Otro método de
tratar algunos de los problemas de una señal global de reloj es la completa
remoción de la misma. Mientras que quitar la señal global del reloj hace, de
muchas maneras, considerablemente más complejo el proceso del diseño, en
comparación con diseños síncronos similares, los diseños asincrónicos (o sin reloj)
tienen marcadas ventajas en el consumo de energía y la disipación de calor.
Aunque se trate de algo infrecuente, las CPUs completas se han construido sin
utilizar una señal global de reloj. Dos notables ejemplos de esto son el AMULET,
que implementa la arquitectura del ARM, y el MiniMIPS, compatible con el MIPS
R3000. En lugar de remover totalmente la señal del reloj, algunos diseños de CPU
permiten que ciertas unidades del dispositivo sean asincrónicas, como por
ejemplo, usando ALU en conjunción con pipelining superescalar para alcanzar
algunas ganancias en el desempeño aritmético. Mientras que no esté
completamente claro si los diseños totalmente asincrónicos pueden
desempeñarse a un nivel comparable o mejor que sus contrapartes síncronas, es
evidente que por lo menos sobresalen en las operaciones matemáticas más
simples. Esto, combinado con sus excelentes características de consumo de
energía y disipación de calor, los hace muy adecuados para sistemas
embebidos.8

Paralelismo
Artículo principal: Computación paralela

Modelo de un CPU subescalar. Note que toma quince ciclos para terminar tres
instrucciones.
La descripción de la operación básica de un CPU ofrecida en la sección anterior
describe la forma más simple que puede tomar un CPU. Este tipo de CPU,
usualmente referido como subescalar, opera sobre y ejecuta una sola instrucción
con una o dos piezas de datos a la vez.

Este proceso da lugar a una ineficacia inherente en CPU subescalares. Puesto

que solamente una instrucción es ejecutada a la vez, todo el CPU debe esperar
que esa instrucción se complete antes de proceder a la siguiente instrucción.
Como resultado, la CPU subescalar queda "paralizado" en instrucciones que
toman más de un ciclo de reloj para completar su ejecución. Incluso la adición de
una segunda unidad de ejecución (ver abajo) no mejora mucho el desempeño. En
lugar de un camino quedando congelado, ahora dos caminos se paralizan y
aumenta el número de transistores no usados. Este diseño, en donde los recursos
de ejecución de la CPU pueden operar con solamente una instrucción a la vez,
solo puede, posiblemente, alcanzar el desempeño escalar (una instrucción por
ciclo de reloj). Sin embargo, el desempeño casi siempre es subescalar (menos de
una instrucción por ciclo).

Las tentativas de alcanzar un desempeño escalar y mejor, han resultado en una

variedad de metodologías de diseño que hacen comportarse al CPU menos
linealmente y más en paralelo. Cuando se refiere al paralelismo en los CPU,
generalmente son usados dos términos para clasificar estas técnicas de diseño.

El paralelismo a nivel de instrucción, en inglés instruction level parallelism (ILP),

busca aumentar la tasa en la cual las instrucciones son ejecutadas dentro de un
CPU, es decir, aumentar la utilización de los recursos de ejecución en la pastilla.
El paralelismo a nivel de hilo de ejecución, en inglés thread level parallelism (TLP),
que se propone incrementar el número de hilos (efectivamente programas
individuales) que un CPU pueda ejecutar simultáneamente.
Cada metodología se diferencia tanto en las maneras en las que están
implementadas, como en la efectividad relativa que producen en el aumento del
desempeño de la CPU para una aplicación.nota 10

ILP: Segmentación y arquitectura superescalar

Artículos principales: Segmentación (electrónica) y Superescalar.

Tubería básica de cinco etapas. En el mejor de los casos, esta tubería puede
sostener un ratio de completado de una instrucción por ciclo.
Uno de los métodos más simples para lograr incrementar el paralelismo es
comenzar los primeros pasos de leer y decodificar la instrucción antes de que la
instrucción anterior haya terminado de ejecutarse. Esta es la forma más simple de
una técnica conocida como segmentación (instruction pipelining en inglés), y es
utilizada en casi todas los CPU de propósito general modernos. Al dividir la ruta de
ejecución en etapas discretas, la tubería permite que más de una instrucción sea
ejecutada en cualquier tiempo. Esta separación puede ser comparada a una línea
de ensamblaje, en la cual una instrucción es hecha más completa en cada etapa
hasta que sale de la tubería de ejecución y es retirada del mismo.

Sin embargo, la tubería introduce la posibilidad de una situación donde es

necesario terminar el resultado de la operación anterior para completar la
operación siguiente; una condición llamada a menudo como conflicto de
dependencia de datos. Para hacer frente a esto, debe ser tomado un cuidado
adicional para comprobar estas clases de condiciones, y si esto ocurre, se debe
retrasar una porción de la tubería de instrucción. Naturalmente, lograr esto
requiere circuitería adicional, los procesadores entubados son más complejos que
los subescalares, pero no mucho. Un procesador entubado puede llegar a ser casi
completamente escalar, solamente inhibido por las abruptas paradas de la tubería
(una instrucción durando más de un ciclo de reloj en una etapa).

Segmentación superescalar simple. Al leer y despachar dos instrucciones a la vez,

un máximo de dos instrucciones por ciclo pueden ser completadas.
Una mejora adicional sobre la idea del entubado de instrucción (instruction
pipelining) condujo al desarrollo de un método que disminuye incluso más el
tiempo ocioso de los componentes del CPU. Diseños que se dice que son
superescalares incluyen una larga tubería de instrucción y múltiples unidades de
ejecución idénticas.9 En una tubería superescalar, múltiples instrucciones son
leídas y pasadas a un despachador, que decide si las instrucciones se pueden o
no ejecutar en paralelo (simultáneamente). De ser así, son despachadas a las
unidades de ejecución disponibles, dando por resultado la capacidad para que
varias instrucciones sean ejecutadas simultáneamente. En general, cuanto más
instrucciones un CPU superescalar es capaz de despachar simultáneamente a las
unidades de ejecución en espera, más instrucciones serán completadas en un
ciclo dado.

La mayor parte de la dificultad en el diseño de una arquitectura superescalar de

CPU descansa en crear un despachador eficaz. El despachador necesita poder
determinar rápida y correctamente si las instrucciones pueden ejecutarse en
paralelo, tan bien como despacharlas de una manera que mantenga ocupadas
tantas unidades de ejecución como sea posible. Esto requiere que la tubería de
instrucción sea llenada tan a menudo como sea posible y se incrementa la
necesidad, en las arquitecturas superescalares, de cantidades significativas de
caché de CPU. Esto también crea técnicas para evitar peligros como la predicción
de bifurcación, ejecución especulativa, y la ejecución fuera de orden, cruciales
para mantener altos niveles de desempeño. Tratando de predecir qué rama (o
trayectoria) tomará una instrucción condicional, la CPU puede minimizar el número
de veces que todo el canal debe esperar hasta que se complete una instrucción
condicional. Frecuentemente, la ejecución especulativa proporciona aumentos
modestos del desempeño al ejecutar porciones de código que no puede ser
necesario después de completarse una operación condicional. Fuera de la orden
de ejecución cambia de algún modo el orden en que se ejecutan las instrucciones
para reducir retardos debido a las dependencias de datos. También en el caso de
instrucciones individuales de datos múltiples — los procesadores modernos, en
caso de que se hayan procesado una gran cantidad de datos del mismo tipo,
pueden desactivar partes de la tubería de manera que cuando se ejecuta una sola
sentencia muchas veces, la CPU salta la captación y decodifica fases y por lo
tanto aumenta considerablemente el rendimiento en ciertas ocasiones, sobre todo
en los motores de programas altamente monótonos como el software de creación
de video y procesamiento de fotografías.
En el caso donde una porción de la CPU es superescalar y una parte no lo es, la
parte que no es superescalar sufre en el desempeño debido a las paradas de
horario. El Intel Pentium original (P5) tenía dos ALUs superescalares que podían
aceptar, cada una, una instrucción por ciclo de reloj, pero su FPU no podía aceptar
una instrucción por ciclo de reloj. Así el P5 era superescalar en la parte de
números enteros pero no era superescalar de números de coma (o punto
[decimal]) flotante. El sucesor a la arquitectura del Pentium de Intel, el P6, agregó
capacidades superescalares a sus funciones de coma flotante, y por lo tanto
produjo un significativo aumento en el desempeño de este tipo de instrucciones.

Tanto el diseño superescalar como el entubado simple aumentan el ILP de una

CPU al permitir a un solo procesador completar la ejecución de instrucciones en
ratios que sobrepasan una instrucción por ciclo (IPC).nota 11 La mayoría de los
modernos diseños de CPU son por lo menos algo superescalares, y en la última
década, casi todos los diseños de CPU de propósito general son superescalares.
En los últimos años algo del énfasis en el diseño de computadores de alto ILP se
ha movido del hardware del CPU hacia su interfaz de software, o ISA. La
estrategia very long instruction word o VLIW, causa a algún ILP a ser implícito
directamente por el software, reduciendo la cantidad de trabajo que el CPU debe
realizar para darle un empuje significativo al ILP y por lo tanto reducir la
complejidad del diseño.

Paralelismo a nivel de hilos

Otra estrategia para lograr el rendimiento es ejecutar varios programas o hilos en
paralelo. Esta área de investigación se conoce como computación paralela. En la
taxonomía de Flynn, esta estrategia se conoce como múltiples instrucciones de
varios datos o MIMD.

Una tecnología utilizada para este propósito fue el multiprocesamiento (MP). El

puntapié inicial de esta tecnología se conoce como multiprocesamiento simétrico
(SMP), donde un pequeño número de CPU comparten una visión coherente de su
sistema de memoria. En este esquema, cada CPU tiene un hardware adicional
para mantener una visión constantemente actualizada de la memoria. Para evitar
visitas rancias de la memoria, las CPU pueden cooperar en el mismo programa y
los programas pueden migrar desde una CPU a otra. Para aumentar el número de
CPUs que cooperan más allá de unas pocas, se introdujeron en 1990, los
esquemas tales como el non-uniform memory Access (acceso no uniforme a
memoria) (NUMA) y los protocolos de coherencia basados en directorios. Los
sistemas SMP se limitan a un pequeño número de CPU mientras que los sistemas
NUMA se han construido con miles de procesadores. Inicialmente, el
multiprocesamiento se construyó usando múltiples CPUs discretas y tableros para
implementar la interconexión entre los procesadores. Cuando los procesadores y
su interconexión hayan sido implementadas en un único chip de silicio, la
tecnología se conoce como un procesador multinúcleo.

Posteriormente, se reconoció que existía un paralelismo muy estrecho con un

único programa. Un único programa podría tener varios hilos (o funciones) que
podrían ser ejecutadas por separado o en paralelo. Algunos de los primeros
ejemplos de esta tecnología implementaba procesamiento de entrada/salida tales
como el acceso directo a memoria como un hilo separado del hilo computado. En
la década de 1970, se introdujo un enfoque más general a esta tecnología, cuando
se diseñaron sistemas para ejecutar múltiples hilos de computación en paralelo.
Esta tecnología se conoce como multihilo (MT).

Este enfoque se considera más rentable que la del multiprocesamiento, ya que

solo se replica un pequeño número de componentes dentro de una CPU para
soportar MT en oposición a la totalidad de la CPU en el caso de MP. En MT, las
unidades de ejecución y el sistema de memoria incluyendo los cachés son
compartidos entre varios hilos. La desventaja de MT es que el soporte de
hardware para multihilo es más visible para el software que la de MP y por lo tanto
el software supervisor como el de los sistemas operativos tienen que someterse a
los cambios más grandes para apoyar MT. Un tipo de MT que se implementó es
conocido como bloque multihilo, donde se ejecuta un hilo hasta que se paralice
esperando que regresen los datos desde la memoria externa. En este esquema, la
CPU tendría luego que cambiar rápidamente a otro hilo que está listo para
funcionar, el interruptor muchas veces realiza un ciclo de reloj de la CPU, como la
tecnología UltraSPARC. Otro tipo de MT se denomina multihilo simultáneo, en
donde las instrucciones de múltiples hilos se ejecutan en paralelo dentro de un
ciclo de reloj de la CPU.

Un menos común pero cada vez más importante paradigma de CPU (y de hecho,
de computación en general) trata con vectores. Los procesadores de los que se ha
hablado anteriormente son todos referidos como cierto tipo de dispositivo
escalar.nota 12 Como implica su nombre, los procesadores vectoriales se ocupan
de múltiples piezas de datos en el contexto de una instrucción, esto contrasta con
los procesadores escalares, que tratan una pieza de dato por cada instrucción.
Estos dos esquemas de ocuparse de los datos son generalmente referidos
respectivamente como SISD (single instruction, single data) y SIMD (single
instruction, multiple data). La gran utilidad en crear CPU que se ocupen de
vectores de datos radica en la optimización de tareas que tienden a requerir la
misma operación, por ejemplo, una suma, o un producto escalar, a ser realizado
en un gran conjunto de datos. Algunos ejemplos clásicos de este tipo de tareas
son las aplicaciones multimedia (imágenes, vídeo, y sonido), así como muchos
tipos de tareas científicas y de ingeniería. Mientras que una CPU escalar debe
completar todo el proceso de leer, decodificar, y ejecutar cada instrucción y valor
en un conjunto de datos, una CPU vectorial puede realizar una simple operación
en un comparativamente grande conjunto de datos con una sola instrucción. Por
supuesto, esto es solamente posible cuando la aplicación tiende a requerir
muchos pasos que apliquen una operación a un conjunto grande de datos.

La mayoría de las primeras CPU vectoriales, como el Cray-1, se asociaron casi

exclusivamente a aplicaciones de investigación científica y criptografía. Sin
embargo, a medida que la multimedia se desplazó en gran parte a medios
digitales, ha llegado a ser significativa la necesidad de una cierta forma de SIMD
en CPUs de propósito general. Poco después de que comenzara a ser común
incluir unidades de coma flotante en procesadores de uso general, también
comenzaron a aparecer especificaciones e implementaciones de unidades de
ejecución SIMD para las CPU de uso general. Algunas de estas primeras
especificaciones SIMD, como el MMX de Intel, fueron solamente para números
enteros. Esto demostró ser un impedimento significativo para algunos
desarrolladores de software, ya que muchas de las aplicaciones que se
beneficiaban del SIMD trataban sobre todo con números de coma flotante.
Progresivamente, estos primeros diseños fueron refinados y rehechos en alguna
de las comunes, modernas especificaciones SIMD, que generalmente están
asociadas a un ISA. Algunos ejemplos modernos notables son el SSE de Intel y el
AltiVec relacionado con el PowerPC (también conocido como VMX)
El "desempeño" (performance) o la velocidad de un procesador depende de, entre
muchos otros factores, la velocidad del reloj (generalmente dada en múltiplos de
hertz) y las instrucciones por ciclo de reloj (IPC), que juntos son los factores para
las instrucciones por segundo (IPS) que el CPU puede rendir.10Muchos reportes
de valores IPS han representado tasas de ejecución "pico" en secuencias de
instrucciones artificiales con pocas ramas, mientras que las cargas de trabajo
realistas consisten en una combinación de instrucciones y de aplicaciones,
algunas de las cuales requieren más tiempo para ejecutar que otras. El
rendimiento de la jerarquía de memoria también afecta en gran medida al
rendimiento del procesador, un tema muy poco tenido en cuenta en los cálculos de
MIPS. Debido a estos problemas, para este fin, se han desarrollado varios
exámenes estandarizados, tales como SPECint muchas veces llamados "puntos
de referencia" - para tratar de medir el rendimiento real efectivo en aplicaciones de
uso cotidiano.

El desempeño de procesamiento de las computadoras se incrementa utilizando

procesadores multinúcleo, que en esencia es conectar dos o más procesadores
individuales (llamados núcleos en este sentido) en un solo circuito integrado.11
Idealmente, un procesador de doble núcleo sería casi dos veces tan potente como
un procesador de núcleo único. En la práctica, la ganancia de desempeño es
mucho menor, solo alrededor del 50%, 12 debido a la implementación de
algoritmos imperfectos de software.13 El aumento del número de núcleos en un
procesador (es decir, dual-core, quad-core, etc) aumenta la carga de trabajo que
se puede manejar. Esto significa que el procesador ahora puede manejar
numerosos eventos asíncronos, interrupciones, etc que pueden tomar un "peaje"
en la CPU (Central Processing Unit) cuando se abruma. Estos núcleos pueden
considerarse como diferentes plantas en una planta de procesamiento, con el
manejo de cada piso una tarea diferente. En ocasiones, estos núcleos se manejan
las mismas tareas que los núcleos adyacentes a ellos si un solo núcleo no es
suficiente para manejar la información.

Debido a las capacidades específicas de las CPU modernas, como Hyper-

Threading y Uncore, que implican el intercambio de recursos reales de la CPU
mientras que el objetivo de una mayor utilización, supervisar los niveles de
rendimiento y la utilización del hardware se fue convirtiendo gradualmente en una
tarea más compleja. Como respuesta, algunas CPUs implementan lógica de
hardware adicional que controla la utilización real de las diversas partes de una
CPU y proporciona varios contadores accesibles a software; un ejemplo es la
tecnología Performance Counter Monitor ("Monitor de contador de rendimiento")
de Intel.
 Organización del procesador
Un procesador, incluye tanto registros visibles por el usuario como registros de
control/estado. Los registros visibles por el usuario pueden ser de uso general o
tener una utilidad especial, mientras que los registros de control y estado se usan
para controlar el funcionamiento del procesador, un claro ejemplo es el contador
de programa. Los procesadores utilizan la segmentación de instrucciones para
acelerar la ejecución. La segmentación de cauce se puede dividir en ciclo de
instrucción en varias etapas separadas que operan secuencialmente, tales como
la captación de instrucción, decodificación de instrucción, cálculo de direcciones
de operando, ejecución de instrucción y estructura del operando resultado.

Estructura de registros

El Registro está organizado en una estructura jerárquica compuesta por

subárboles con sus respectivas claves, subclaves y entradas. El contenido del
Registro puede variar considerablemente de un equipo a otro, en función de los
dispositivos, servicios y programas instalados en cada equipo. Las claves pueden
contener subclaves que, a su vez, pueden contener otras subclaves. Aunque la
mayor parte de la información del Registro se almacena en disco y se considera
permanente, algunos datos almacenados en claves volátiles se sobrescriben cada
vez que se inicia el sistema operativo.

Registros visibles para el usuario

Minimizan el acceso entre el microprocesador y cpu, debido a que se encuentran
dentro del CPU, son manipulables por lenguaje de máquina. Aquí tenemos los 2
principales:
1) Registros de Datos. (Manipulables a bajo nivel).
2) Registro de Direcciones (Manipulables a bajo nivel).

• Registro de índice.
Sirve para direccionamiento, es similar al “PC”, pero tiene un valor base de
autoincremento: Ejemplo: Base 3  3, 6, 9…n, n+1; que se irá sumando para
obtener una dirección más efectiva.

Registros de control y de estados

Hay diversos registros del procesador que se emplean para controlar su

funcionamiento. La mayoría de ellos, en la mayor parte de las máquinas, no son
visibles por el usuario. Algunos de ellos pueden ser visibles por ciertas
instrucciones máquina ejecutadas en un modo de controlo de sistema operativo.
Naturalmente, máquinas diferentes tendrán distintas organizaciones de registros y
usarán distinta terminología. A continuación se presenta una lista razonablemente
completa de tipos de registros, con una breve descripción
. Son esenciales cuatro registros para la ejecución de una instrucción:
 Contador de programa (Program Counter, PC): contiene la dirección de la
instrucción a captar.
 Registro de instrucción (lnstruction Register, IR): contiene la instrucción captada
más recientemente.
 Registro de dirección de memoria (Memory Address Register, MAR): contiene la
dirección de una posición de memoria.
 Registro intermedio de memoria (Memory Buffer Register, MBR): contiene la
palabra de datos a escribir en memoria o la palabra leída más recientemente.

No todos los procesadores tienen registros internos designados como MAR y

MBR, pero es necesario algún mecanismo de almacenamiento intermedio
equivalente mediante el cual se dé salida a los bits que van a ser transferidos al
bus del sistema y se almacenen temporalmente los bits leídos del bus de datos.
Típicamente, el procesador actualiza PC después de cada captación de
instrucción de manera que siempre apunta a la siguiente instrucción a ejecutar.
Una instrucción de bifurcación o salto también modificará el contenido de PC. La
instrucción captada se carga en IR, donde son analizados el código de operación y
los campos de operando. Se intercambian datos con la memoria por medio de
MAR y de MBR.
En un sistema con organización de bus, MAR se conecta directamente al bus de
direcciones, y MBR directamente al bus de datos. Los registros visibles por el
usuario repetidamente intercambian datos con MBR. Los cuatro registros que se
acaban de mencionar se usan para la transferencia de datos entre el procesador y
la memoria. Dentro del procesador, los datos tienen que ofrecerse a la ALU para
su procesamiento.
La ALU puede tener acceso directo a MBR y a los registros visibles por el usuario.
Como alternativa, puede haber registros intennedios adicionales en tomo a la ALU;
estos registros sirven como registros de entrada y salida de la ALU e intercambian
datos con MBR y los registros visibles por el usuario.

Ejemplos de organización de registros de CPU reales

En algún diseño concreto de procesador es posible encontrar otros registros

relativos a estado y control. Puede existir un puntero a un bloque de memoria que
contenga información de estado adicional (por ejemplo, bloques de control de
procesos). En las máquinas que usan interrupciones vectorizadas puede existir un
registro de vector de interrupción. Si se utiliza una pila para llevar a cabo ciertas
funciones (por ejemplo, llamada a subrutina), se necesita un puntero de pila del
sistema. En un sistema de memoria virtual se usa un puntero a la tabla de
páginas. Por último, pueden emplearse registros para el control de operaciones de
E/S.
En el diseño de la organización de los registros de control y estado entran en
juego varios factores.
Una cuestión primordial es el soporte del sistema operativo. Algunos tipos de
información de control son de utilidad específica para el sistema operativo. Si el
diseñador del procesador posee una comprensión funcional del sistema operativo
que se va a utilizar, la organización de los registros puede adaptarse hasta cierto
punto a ese sistema operativo.

Otra decisión importante en el diseño es la distribución de información de control

entre registros y memoria. Es frecuente dedicar los primeros (más bajos) pocos
cientos o miles de palabras de memoria para fines de control. El diseñador debe
decidir cuánta información de control debiera estar en registros y cuánta en
memoria. Se presenta el compromiso habitual entre coste y velocidad.

Ciclo Fetch-Decode-Execute

Un ciclo de instrucción (también llamado ciclo de fetch-and-execute o ciclo de

fetch-decode-execute en inglés) es el período que tarda la unidad central de
proceso (CPU) en ejecutar una instrucción delenguaje máquina. Comprende una
secuencia de acciones determinada que debe llevar a cabo la CPU para ejecutar
cada instrucción en un programa. Cada instrucción del juego de instrucciones de
una CPU puede requerir diferente número de ciclos de instrucción para su
ejecución. Un ciclo de instrucción está formado por uno o más ciclos máquina.

Un ciclo de instrucción (también llamado ciclo de fetch-and-execute o ciclo de

fetch-decode-execute en inglés) es el período que tarda la unidad central de
proceso (CPU) en ejecutar una instrucción de lenguaje máquina. Comprende una
secuencia de acciones determinada que debe llevar a cabo la CPU para ejecutar
cada instrucción en un programa. Cada instrucción del juego de instrucciones de
una CPU puede requerir diferente número de ciclos de instrucción para su
ejecución. Un ciclo de instrucción está formado por uno o más ciclos máquina.

Conjunto de instrucciones: Características y funciones

La segmentación de instrucciones es similar al uso de una cadena de montaje en
una fábrica de manufacturación. En las cadenas de montaje, el producto pasa a
través de varias etapas de producción antes de tener el producto terminado. Cada
etapa o segmento de la cadena está especializada en un área específica de la
línea de producción y lleva a cabo siempre la misma actividad. Esta tecnología es
aplicada en el diseño de procesadores eficientes.
A estos procesadores se les conoce como pipeline processors. Estos están
compuestos por una lista de segmentos lineales y secuenciales en donde cada
segmento lleva a cabo una tarea o un grupo de tareas computacionales. Los datos
que provienen del exterior se introducen en el sistema para ser procesados. La
computadora realiza operaciones con los datos que tiene almacenados en
memoria, produce nuevos datos o información para uso externo.
Las arquitecturas y los conjuntos de instrucciones se pueden clasificar
considerando los siguientes aspectos:
Almacenamiento de operandos en la CPU: dónde se ubican los operandos aparte
de la memoria.
Número de operandos explícitos por instrucción: cuántos operandos se expresan
en forma explícita en una instrucción típica. Normalmente son 0, 1, 2 y 3.

Posición del operando: ¿Puede cualquier operando estar en memoria?, o deben

estar algunos o todos en los registros internos de la CPU. Cómo se especifica la
dirección de memoria (modos de direccionamiento disponibles). Operaciones: Qué
operaciones están disponibles en el conjunto de instrucciones. Tipo y tamaño de
operandos y cómo se especifican.

Modos de direccionamiento y formatos

El campo de operación de una instrucción especifica la operación que se debe

realizar. Esta debe ser ejecutada sobre algunos datos almacenados en registros
del computador o en palabras de memoria, es decir, sobre los operandos. El modo
de direccionamiento especifica la forma de interpretar la información contenida en
cada campo de operando para localizar, en base a esta información, el operando.
 Estructura de registro

Un registro, en programación, es un tipo de dato estructurado formado por la unión

de varios elementos bajo una misma estructura. Estos elementos pueden ser, o
bien datos elementales (entero, real, carácter,...), o bien otras estructuras de
datos. A cada uno de esos elementos se le llama campo.

Un registro se diferencia de un vector en que éste es una colección de datos

iguales, es decir, todos del mismo tipo, mientras que en una estructura los
elementos que la componen, aunque podrían serlo, no tiene por qué ser del
mismo tipo.

Ejemplo: Creación de un registro (o estructura) en C

Un ejemplo de como se declararía un registro en C podría ser:

Ilustración 1 ejemplo creacion de un regristro en C

En este ejemplo se define el tipo de dato TNodo (o struct TipoNodo, sería

equivalente) como una estructura (registro) que contiene un dato de tipo entero y
dos punteros sig y ant (siguiente y anterior) que sirven para referenciar a otros
registros del tipo TNodo. Ésta es la estructura de datos que se suele utilizar como
nodo en las listas doblemente enlazadas.
 Registro en bases de datos

El concepto de registro que se acaba de presentar es muy similar al concepto de

registro en bases de datos, este segundo se refiere a una colección de datos que
hacen referencia a un mismo ítem que se van a guardar en una fila de una tabla
de la base de datos

Registros
Un registro es una estructura de datos formado por un conjunto de elementos
llamados campos, no necesariamente del mismo tipo y que permiten almacenar
una serie de datos relacionados entre sí bajo un nombre común.

Declaración Un registro se declara de la siguiente

manera:

Ilustración 2 tabla de declaracion registro

Ilustración 3 ejemplo se declara un registro y luego variables de ese tipo de registro

Operaciones

A los registros se le pueden aplicar varias operaciones, como aplicar la operación

constructora para inicializarlos o la operación selectora para cambiar los valores
de los campos.
Utilizando el registro y las variables declaradas en ejemplo anterior, se pueden
aplicar las siguientes operaciones:

Ilustración 4 registro y las vaiables

 Pase de parámetros
Para pasar un registro como parámetro a una acción o función se puede hacer de
la siguiente manera:

Ilustración 5 pase de parámetros

A continuación se presenta un ejemplo donde se define un registro el cual

representa cartas, indicando el número o cara de las cartas, así como también la
pinta o palo. Este algoritmo permite definir un arreglo del tipo carta, para manejar
así las cartas que forman parte de un mazo.
Ilustración 6 Este algoritmo permite definir un arreglo del tipo carta

Ejercicios
1. Proporcione la definición de los registros para cada uno de los siguientes casos:
a. El registro fecha que contiene tres enteros dia, mes y año (anio).
 b. El registro persona que contiene dos cadenas de caracteres nombre y apellido,
un campo del tipo fecha (definido previamente) fecha_de_nacimiento
2. Partiendo de los registros definidos previamente, desarrolle un algoritmo en el
cual se definan dos variables correspondientes a dos personas, solicite la
información necesaria al usuario para asignarle los valores de nombre, apellido y
fecha de nacimiento de cada uno y luego muestre la información por pantalla.
Haga uso de procedimientos.

Archivos
Un archivo es una secuencia de elementos del mismo tipo, que residen
generalmente en memoria auxiliar. Los archivos son utilizados cuando se desea
que los datos puedan recuperarse aún después de haber apagado la máquina y
también cuando se manejan grandes volúmenes de información.

Declaración
Antes de empezar a utilizar un archivo se debe declarar una variable que haga
referencia al archivo con el que se va a trabajar. A continuación se muestra como
se puede hacer:

Ilustración 7 declaracion

Operaciones
Al trabajar con archivos secuenciales se pueden realizar diversas operaciones
tales como:
• Abrir el archivo: se debe hacer antes de hacer otras operaciones en le archivo.
• Cerrar el archivo: se debe hacer cuando se termina de utilizar el archivo.
• Verificar el fin del archivo (FDA o EOF).
• Leer del archivo.
• Escribir en el archivo.
A continuación se muestran ejemplos de estas operaciones utilizando los archivos
declarados anteriormente.

Ilustración 8 Ejemplo de abrir archivos

Ilustración 9 lectura de un archivo caracter por caracter (asumiendo que el archivo está abierto y es de
lectura)
Ilustración 10 escritura en un archivo (asumiendo que el archivo está abierto y es de escritura)

Ilustración 11 ejemplo permite leer la información almacenada en un archivo “info.dat”

Toma en consideración que para ejecutar este ejemplo debes contar con un
archivo “info.dat”, el cual puede tener inicialmente los siguientes valores:
Maria 20.4
Jose 17.4
Pedro 56.7
Carlos 67.1

,
Ilustración 12 ejemplo permite crear un archivo e ingresar la información en un archivo “info.dat”.

Ejercicios:
1.- Considere que usted es el dueño de una tienda de herramientas y necesita
mantener un inventario que le permita llevar un control mínimo de cuáles
herramientas tiene, cuántas tiene y el costo de cada una. Escriba un programa
que:
a.- le permita listar todas sus herramientas
b.- le permita introducir nuevas herramientas.
c.- le permita actualizar la información de la cantidad de una herramienta en
particular.
Almacene la información en un archivo identificado como “inventario.txt” y
considere que el mismo tiene la siguiente información inicialmente:
Ilustración 13 Inventario

ORGANIZACIÓN DE LA UNIDAD CENTRAL DE PROCESO

(CPU)
La Unidad Central de Proceso es la encargada de la ejecución de las instrucciones
Para ello la arquitectura de von Neumann propone que la misma cuente con los
siguientes elementos básicos:
Unidad Aritmética-Lógica (ALU): circuito lógico que implementa operaciones de
aritmética binaria (típicamente la operaciones básicas para representaciones
"binario" y "complemento a 2" y lógicas (típicamente AND, OR, EXOR y NOT bit a
bit). También es habitual que implemente operaciones de desplazamiento y/o
rotación de bits.
- Unidad de Control: circuito secuencial que implementa el denominado "ciclo de
instrucción", permitiendo acceder a la siguiente instrucción de un programa, leer
sus operandos, efectuar la operación indicada en la ALU y guardar el resultado de
la misma.
- Banco (Set / Conjunto) de Registros: una serie de posiciones especiales de
memoria, ubicadas físicamente dentro de la propia CPU, que permiten un acceso
a operandos y lugares de almacenamiento de resultados mucho más veloz que si
estuvieran en el sistema de memoria normal. Algunos de estos registros son de
uso interno de la propia CPU (más precisamente de su Unidad de Control) y otros
son accesibles y utilizables por el programador..
Notemos que el Banco (Set / Conjunto) de Registros no es un elemento esencial
de la arquitectura. Es un elemento de carácter tecnológico que tiene que ver con
dos aspectos:
- por razones vinculadas a la electrónica, la velocidad de transferencia de
información entre dos circuitos está limitada por la distancia geográfica entre los
mismos
- la memoria rápida (usada en los pocos registros de la CPU) es más cara que la
memoria más lenta (usada en las mucho más abundantes posiciones del sistema
de memoria principal).
De allí que se utilice poca memoria rápida (por el costo) y que se ubique en las
cercanías de donde se va a utilizar (dentro de la CPU) para minimizar su tiempo
de acceso.
 Componentes Básicos de la CPU

Como ya dijimos antes una CPU (Centrol Processor Unit) está conformada por
tres sub-sistemas fundamentales: la ALU (Arithmetic Logic Unit, Unidad Aritmética
y Lógica), la CU (Control Unit, Unidad de Control) y el Register Set (también
denominado Register Bank) ó sea Conjunto (o Banco) de Registros.

El Banco de Registros contiene registros de tres categorías desde el punto de

vista de su función en relación con los programas y el funcionamiento interno de la
CPU:
- Totalmente visibles: estos son los ya mencionados registros de uso general ó
personalizados que contienen operandos o direcciones para su utilización en las
instrucciones. El programador de “bajo nivel” los manipula directamente en los
programas.
- Parcialmente visibles: son registros que tienen funciones especiales pero
participan de algún modo indirecto en las instrucciones. El programador los
manipula indirectamente en determinadas instrucciones específicas. Ejemplos de
este tipo de registros son el IP (Instruction Pointer), también denominado PC
(Program Counter) que contiene la dirección de la próxima instrucción a ejecutarse
(en algunas arquitecturas almacena la dirección de la que se está ejecutando en
este momento), el SP (Stack Pointer) que contiene el puntero al primer lugar de la
pila en las arquitecturas “de stack” y el PS (Processor Status) también
denominado registro de FLAGS (en el caso de Intel) que contiene el estado del
procesador incluyendo el valor que tomaron los bits de condición (Negative, Zero,
Carry, Overflow) en función del resultado de la última operación realizada por la
ALU.
- Internos: son registros que utiliza la Unidad de Control de la CPU para poder
ejecutar las instrucciones. Almacenan constantes, el estado de la CU, la
instrucción en ejecución (su código binario), resultados intermedios de cálculos de
direcciones, etc. No son visibles de ninguna manera al programador.
La Unidad de Control es, en definitiva, una máquina secuencial que realiza el
“ciclo de instrucción”: conjunto de acciones ordenado y secuencial que
interconectan adecuadamente los distintos elementos en el tiempo, para lograr el
objetivo de ejecutar la instrucción realizando la operación indicada sobre los
operandos correspondientes y almacenando el resultado en el lugar indicado. Esta
máquina secuencial funciona sincronizada por un reloj, el cual también es utilizado
para sincronizar todas las actividades de los otros elementos del sistema
(memoria y entrada/salida). En las primeras computadoras el reloj era el mismo
para todos los elementos. Últimamente se utilizan relojes independientes (aunque
vinculados) para cada sub-sistema. En muchos diseños se utilizan más de un reloj
para la CPU, con la misma frecuencia, pero desfasados (0º, 90º, 180º y 270º, por
ejemplo) a los efectos de ser utilizados para sincronizar distintas partes del circuito
compensando los diferentes retardos de propagación de las señales en los
circuitos internos de la CPU. En la figura siguiente se muestra un ejemplo de
organización de una unidad de control (tomado de la “computadora básica” de
Arquitectura de Computadoras de Morris Mano). Esta formado por dos
decodificadores, un contador secuencial, y cierta cantidad de
compuertas lógicas de control. Una instrucción leída de la memoria se coloca en el
registro de la instrucción actual (IR). Se utiliza un decodificador para decodificar el
código de operación y enviar las señales de control las compuertas lógicas. Los
bits de los operandos se conectan directamente a las compuertas lógicas.
Finalmente, se utiliza un decodificador para las señales del contador, cuya salida
se utilizará para habilitar las distintas funciones implementadas en las compuertas
lógicas de control.

Ilustración 14 instruction registro (IR)

La Unidad Aritmética y Lógica es un conjunto de circuitos (típicamente

combinatorios) que implementan un conjunto de operaciones, que incluyen suma y
resta (en aritmética complemento a 2), operaciones lógicas bit a bit (AND, OR,
EXOR, NOT) y operaciones de desplazamiento (shift). Las ALUs más avanzadas
incluyen operaciones de multiplicación y división (aunque en este caso se
implementan como una máquina secuencial que implementa algún algoritmo para
estas operaciones).

Ciclo de Instrucción
Se denomina ciclo de instrucción a la secuencia de acciones que realiza la CPU
(más específicamente la Unidad de Control) para lograr ejecutar una instrucción
del programa almacenado en memoria.

Un ciclo de instrucción típico tiene 5 pasos característicos:

- Fetch: este paso consiste en leer la próxima instrucción a ejecutarse desde la
memoria.
- Decode: en este paso se analiza el código binario de la instrucción para
determinar qué se debe realizar (cuál operación, con qué operandos y donde
guardar el resultado)
- Read: en este paso se accede a memoria para traer los operandos
- Execute: es la ejecución de la operación por parte de la ALU sobre los operandos
- Write: en el último paso se escribe el resultado en el destino indicado en la
instrucción.

Notemos que no todas las instrucciones requieren de todos los pasos indicados
para su ejecución. Por ejemplo las instrucciones que tienen sus operandos en
registros, no requieren del paso “read”, mientras que las que no guardan un
resultado no requieren del paso “write”.

Para realizar estos pasos la unidad de control maneja un conjunto de señales de

control interno a la CPU y otras de control externo (en la interfaz con la memoria y
con el sistema de entrada/salida), las que habilitan las conexiones apropiadas
entre los distintos elementos de forma que el respectivo paso del ciclo se cumpla.
Por ejemplo: para hacer el “fetch” conecta el bus de direcciones de memoria con el
registro PC (que contiene la dirección de la próxima instrucción a ejecutarse),
conecta el bus de datos de memoria con el registro interno IR (Instruction
Register) y coloca en el bus de control de la memoria las señales apropiadas para
realizar una lectura.
Estructura de la CPU
Ilustración 15 diagrama se muestra la estructura de una CPU
En esta propuesta de organización interna se dispone de los siguientes recursos
(es una arquitectura de 16 bits):
Registro PC: contiene el puntero de instrucción (“Program Counter”)
 Registro AC: es el registro ACumulador  Registro SP: contiene el puntero a la
pila (“Stack Pointer”)
 Registro IR: almacena la instrucción leída desde memoria
 Registro TIR: almacena temporalmente copias de la instrucción
 Registro 0: contiene la constante 0
 Regsitro +1: contiene la constante 1 (positiva)
 Registro -1: contiene la constante -1 (negativa en complemento a 2)
 Registros AMASK: contiene el valor binario 0000111111111111 (0x0fff)
 Registros SMASK: 000000001111111 (0x00ff)
 Registros A a F: para uso interno de la Unidad de Control
 Registro MAR (Memory Address Register): almacena la dirección de memoria
que se presenta en el bus de direcciones de la memoria durante una operación de
lectura o escritura de la misma.
 Registro MBR (Memory Buffer Register): almacena el dato leído de la memoria
(en una operación de lectura) o el dato a escribir en la memoria (durante una
operación de escritura).
 AMux: multiplexor que elige entre dos entradas posibles.
 ALU: Unidad Aritmética y Lógica, capaz de ejecutar 4 operaciones: suma A+B, A
and B identidad A (la salida es igual a su entrada A), not A.
 Shifter: unidad encargada de realizar la operación de desplazamiento: 0 bit (no
desplaza nada), 1 bit a la derecha, 1 bit a la izquierda.
 ALatch/BLatch: son registros intermedios utilizados para simplificar los aspectos
de sincronismo de las señales, requeridos porque el diseño original de
Tanenbaum prevé la construcción del banco de registros con Flip-Flops
asíncronos (un diseño basado en FF con reloj por flanco podría evitar el uso de
estos registros intermedios).
Notas:
- La interfaz con la memoria y la E/S se realiza a través del bus de datos, el bus de
direcciones y el bus de control (formado por las señales RD y WR).
- Los registros, la ALU y la unidad de Shift son de 16 bits de tamaño de palabra.
- La unidad de desplazamiento no siempre se explicita como en el ejemplo ya que
se puede considerar que forma parte de la ALU.
- Normalmente las ALUs calculan también las salidas C (Carry) y V (oVerflow).
- Los valores de las constantes de los distintos registros está vinculada con las
necesidades de la “macroarquitectura” asociada a la MIC-1 y no constituyen un
requisito en otras microarquitecturas.
- Tener presente que este es tan solo un ejemplo de cómo se puede construir
internamente una CPU y ni siquiera es uno que pueda considerarse óptimo. Por
razones de simplicidad se ha omitido dibujar la Unidad de Control en el diagrama
anterior. Esta es, como dijimos, una máquina secuencial. Las salidas de este
circuito secuencial son todas las señales de control indicadas en el diagrama, que
actúan sobre los distintos recursos internos y el bus de control externo de manera
de completar los distintos pasos del ciclo de instrucción visto.
Las funciones que cumplirían las distintas señales de control son:

- A3, A2, A1, A0: seleccionan un registro y conectan su salida al bus A (ej:
0000/PC, 0001/AC, 0010/SP, 0010/IR, 0100/TIR, 0101/0, 0110/+1, 0111/-1,
1000/AMASK, 1001/SMASK, 1010/A, 1011/B … 1111/F)
- B3, B2, B1, B0: seleccionan un registro y conectan su salida al bus B (ej: idem a
la codificación para A) - C3, C2, C1, C0: seleccionan un registro y conectan su
entrada al bus C (ej: idem a la codificación para A)
- ENC: habilita el bus C para que se guarde el valor en el registro seleccionado
- X0: selecciona si conecta a su salida la entrada que viene desde el MBR o desde
el bus A (ej: 0 – MBR, 1 – Bus A)
- F1, F0: codifican la operación a realizar por la ALU (ej: 00 – A+B, 01 – A and B,
10 – A, 11 – not A)
- S1, S0: codifican la operación de desplazamiento (ej: 00 – no desplaza, 01 – un
bit a la derecha, 10 – un bit a la izquierda)
- L1, L0: controlan la carga de los registros intermedios del bus B y el bus A
respectivamente.
- M0: controla la carga en el MAR (ej: 1 – carga)
- M1, M2, M3: controlan la forma que se cargan los datos en el MBR, cuando y
desde donde se produce. M1 activa la carga (ej: 1 – carga). M2 es la señal de
lectura de memoria RD (ej: 1 – lee la memoria). M3 es la señal de escritura de
memoria (eg: 1 – escribe la memorias).
Veamos como manejaría la Unidad de Control estas señales de control para lograr
ejecutar el ciclo de instrucción. Consideremos el ejemplo en el que se va a
ejecutar una suma entre un operando en memoria y el acumulador, con modo de
direccionamiento directo (la dirección está en los últimos 12 bits de la instrucción).
El primer paso es el fetch. Para leer la instrucción de memoria se debe cargar el
contenido del registro PC en el MAR, realizar una operación de lectura desde
memoria y se debe conectar el bus de datos con el registro IR, de forma de cargar
en él la instrucción. Para ello hay que:

conectar la salida del registro PC al bus B (B3 = 0, B2 = 0, B1 = 0, B0 = 0)

- seleccionar cargar el BLatch (L0 = 1)
- seleccionar cargar MAR (M0 = 1)
- seleccionar cargar el MBR (M1 = 1)
- seleccionar lectura de memoria (M2 = 1)
- seleccionar MBR en el AMux (X0 = 0)
- seleccionar la operación identidad-A en la ALU (F1 = 1, F0 = 0)
- seleccionar no desplazamiento en el Shifter (S0 = 0, S1 = 0)
- conectar la entrada del registro IR al bus C (C3 = 0, C2 = 0, C1 = 1, C0 = 0)
- habilitar el bus C (ENC = 1)
Al colocar todas estas señales en los valores indicados se procederá a la lectura
de la instrucción contenida en la posición PC de la memoria. Notemos que de
acuerdo a los tiempos de acceso de la memoria se pueden llegar a necesitar
mantener las señales por más de un ciclo de reloj a los efectos de tener en cuenta
las latencias (tiempos de propagación) de la circuitería involucrada
Para completar el paso de fetch es necesario actualizar el valor de PC, para lo que
se requiere las siguientes señales (en el siguiente ciclo de reloj):
- conectar la salida del registro PC al bus B (B3 = 0, B2 = 0, B1 = 0, B0 = 0)
- conectar la salida del registro +1 al bus A (A3 = 0, A2 = 1, A1 = 1, A0 = 0)
- seleccionar cargar el ALatch (L1 = 1)
- seleccionar cargar el BLatch (L0 = 1)
- seleccionar Bus A en el A Mux (X0 = 1)
- seleccionar A + B en la ALU (F1 = 0, F0 = 0)
- seleccionar no desplazamiento en el Shifter (S0 = 0, S1 = 0)
- conectar la entrada del registro PC al bus C (C3 = 0, C2 = 0, C1 = 0, C0 = 0)
- habilitar bus C (ENC = 1)

El siguiente paso del ciclo de instrucción es el decode. La decodificación se realiza

analizando el código binario de la instrucción. Para ello se implementa en la CU
una función mediante un circuito combinatorio que toma como entrada el
contenido del IR y da como salida los valores apropiados de las señales de
control, condicionando también el próximo estado de la máquina secuencial, como
en el caso del ejemplo ya que al reconocer el modo de direccionamiento directo
debe realizarse el paso de read.
Para realizar el paso de read se debe cargar la dirección del operando (contenida
en los últimos 12 bits de la instrucción) en el MAR, para luego realizar una
operación de lectura desde memoria, cargando el MBR desde el bus de datos, de
forma de almacenar en él el operando. Para ello hay que:
conectar la salida del registro IR al bus B (B3 = 0, B2 = 0, B1 = 1, B0 = 0)
- conectar la salida del registro AMASK al bus A (A3 = 1, A2 = 0, A1 = 0, A0 = 0)
- seleccionar cargar el ALatch (L1 = 1)
- seleccionar cargar el BLatch (L0 = 1)
- seleccionar Bus A en el A Mux (X0 = 1)
- seleccionar A and B en la ALU (F1 = 0, F0 = 1)
- seleccionar no desplazamiento en el Shifter (S0 = 0, S1 = 0)
- conectar la entrada del registro A al bus C (C3 = 1, C2 = 0, C1 = 1, C0 = 0)
- habilitar bus C (ENC = 1)
con estas señales y sincronizado por el reloj se guarda la dirección contenida en la
instrucción en el registro A. A continuación (próximo ciclo de reloj) se colocan las
señales:
conectar la salida del registro A al bus B (B3 = 1, B2 = 0, B1 = 1, B0 = 0)
- seleccionar cargar el BLatch (L0 = 1)
- seleccionar cargar MAR (M0 = 1)
- seleccionar cargar el MBR (M1 = 1)
- seleccionar lectura de memoria (M2 = 1)
En el paso siguiente se realiza el execute. Para ello se deben activar las
siguientes señales
conectar la salida del registro AC al bus B (B3 = 0, B2 = 0, B1 = 0, B0 =1)
- seleccionar cargar el BLatch (L0 = 1)
- seleccionar MBR en el A Mux (X0 = 0)
- seleccionar la operación A + B en la ALU (F0 = 0, F1 = 0)
- seleccionar no desplazamiento en el Shifter (S0 = 0, S1 = 0)
- conectar la entrada del registro AC al bus C (C0 = 1, C1 = 1, C2 = 0, C3 =1)
- habilitar bus C (ENC = 1)
Sincronizado por el reloj se realiza la operación en la ALU y se guarda el resultado
en el registro AC.
Cabe destacar que al ser una instrucción cuyo resultado se almacena en un
registro, no corresponde que exista un paso de write.
Hay dos filosofías de diseño claramente diferenciadas para la Unidad de Control:
la “lógica cableada” y la “lógica microprogramada”.
El diseño de la CU en base a la filosofía de “lógica cableada” se hace como
cualquier circuito secuencial. Para el ejemplo anterior deberíamos tomar como
salidas todas las señales de control necesarias y como entradas los bits del código
binario de las instrucciones.
En este caso el resultado es óptimo desde el punto de vista de la velocidad de los
circuitos, pero tiene poca flexibilidad ya que cualquier cambio en el diseño del set
de instrucciones de la CPU genera la necesidad de re-escribir el diagrama de
estados y, por ende, cambiar todo el circuito lógico que lo implementa. En cambio
la filosofía de “lógica microprogramada” propone que la CU se construya en base
a un autómata más sencillo que “ejecute” el ciclo de instrucción de cada
instrucción de la CPU siguiendo en secuencia un conjunto de “microinstrucciones”
que contienen los valores de las señales apropiados para esa instrucción
particular. Es decir que para cada instrucción a nivel de la CPU existirá un
“microprograma”, consistente en una secuencia lógica de microinstrucciones que
establecerán el orden de los eventos necesarios para lograr la ejecución de la
instrucción en la CPU, incluyendo todas las “bifurcaciones” de la secuencia que se
requieran en base a los distintos tipos de direccionamiento y cualquier otra
variante que admita la instrucción específica. En este caso hay una penalización
en la velocidad de proceso porque el microprograma se almacena en una ROM
interna de la CPU y cada microinstrucción debe ser leída de ella, pero simplifica
enormemente la tarea de modificar el set de instrucciones, ya que simplemente
alcanza con cambiar el contenido de la ROM del microprograma. También las
máquinas microprogramadas permiten fácilmente implementar instrucciones
complejas, tales como la búsqueda de un elemento en un array, ó la copia o la
comparación de arrays, etc.
La tendencia en materia de diseño de CPUs era, hasta la década de 1980, utilizar
lógica microprogramada. La aparición de las arquitecturas RISCs puso en cuestión
esa tendencia, ya que dichas propuestas promovían el uso de lógica cableada, en
particular asociado al concepto de optimizar la velocidad de proceso. De todos
modos es probable que la ventaja que esos diseños obtuvieron en materia de
rendimiento se deba principalmente al uso óptimo de técnicas tales como el
“pipelining” permitido por las características de su set de instrucciones. El punto es
que si se usa un set “reducido” con fines de optimización, también resulta más
sencillo implementar la CPU en “lógica cableada”.

La forma de generar estas señales de control, que serían distintas en cada paso
de programa, puede hacerse mediante un código único para cada posible conjunto
de señales, y añadir entonces al hardware de propósito general un segmento que
acepte estos códigos y genere las señales de control adecuadas. Estos códigos
son básicamente las instrucciones que acepta el hardware, y el conjunto de estas
instrucciones sería el software del sistema.
instrucciones constituyen la CPU del sistema. La necesidad de introducir los datos
y almacenar o visualizar los resultados nos llevan a la necesidad de un sistema de
E/S. Por último, debido a que los programas necesitan acceder a datos, se
necesita una memoria que almacene la información y a la que se pueda acceder
en cualquier posición. Así pues, desde un punto de vista de máxima abstracción,
un computador consiste en una CPU, memoria y componentes de E/S, con uno o
más módulos de cada tipo. Estos componentes se interconectan de alguna forma
para obtener la función básica del computador, que es ejecutar programas. Un
microprocesador es básicamente una ALU y una unidad de control integrada en el
mismo chip. Un microcomputador combina un microprocesador con memoria y
unidades de entrada/salida de datos. En la figura se muestra la evolución de los
µP.

• µP DE 4 BITS: Construidos con tecnología PMOS debido a su bajo coste. Estos

µP se siguen utilizando para aplicaciones de bajo coste industriales y de consumo.
• BIT-SLICES: utilizados para aplicaciones que requieran gran potencia de
computación. Se trata de módulos idénticos que contienen CPUs con datos de
pocos bits (típicamente 4). Su disposición en paralelo permite conseguir CPU de
longitudes de palabra múltiplos de la básica, con la ventaja de estar realizados con
tecnologías rápidas (TTL, ECL), aprovechando la estructura simplificada de cada
módulo que no requiere un alto grado de integración. Su uso ha disminuido con la
aparición de µP de longitudes de palabra mayores.
• µP DE 8 BITS: La segunda generación de µP comenzó en 1972 con el 8008 de
Intel. La tecnología NMOS fue adoptada en 1974, permitiendo incrementar sus
funciones y velocidad.
Posteriormente fueron desarrollándose procesadores de periféricos para estos
dispositivos que soportaban otras funciones de control tales como CRT y unidades
de disco. Los µP actuales de 8 bits utilizan generalmente palabras internas de
longitud 16 o 32 bits (por ejemplo, el Intel 8088 y el Motorola 6809). Básicamente
representan versiones de µP de 16 o 32 bits para aplicaciones de bajo coste.
• µP DE 16 BITS: El PACE de National Semiconductor fue el primer µP de 16 bits
(1974) con el. El Intel 8086 aparece en 1978, el Zilog Z8000 en 1979 y el Motorola
68000 en 1980. Utilizan tecnología NMOS mejorada (XMOS, HMOS, etc). Las
principales novedades que introducen son:

Modos de operación protegidos (modo de sistema y modo normal, lo que permite

que un programa supervisor, como un sistema operativo, pueda realizar funciones
prohibidas generalmente a aplicaciones del usuario). • Segmentación y protección
de memoria.

µP DE 32 BITS: El primer µP de 32 bits, el Intel APX 432, aparece en 1981.

Existen otros procesadores posteriores que son básicamente versiones de 32 bits
de modelos anteriores o que mantienen cierta compatibilidad con aquéllos (68020,
80386, etc.). Como características podemos destacar:
• Mayores densidades de integración y velocidades de reloj → Incremento de la
velocidad de proceso.
• Optimización de arquitecturas: pipe-lines de 3 o más etapas, unidades de control
de memoria integradas en el mismo chip, coprocesadores de coma flotante
integrados, etc.
• Nuevas técnicas de manejo de memoria virtual: paginación y técnicas mixtas
paginación-segmentación.
• DSP (Procesadores Digitales de Señal): microprocesadores de uso específico
optimizados para realizar procesado digital de señal en tiempo real. El primer DSP
fue el Intel 2920.
 Estructuras de Interconexión

El conjunto de caminos de interconexión entre los distintos módulos del

computador se denomina 'estructura de interconexión'. De los diferentes tipos de
estructuras de interconexión, la más usual es la interconexión de bus, que es la
única que comentaremos en esta introducción, ya que básicamente es la misma
que se implementa a nivel interno de la CPU para interconexión de sus elementos
constituyentes.
Se denomina 'bus del sistema' al bus que conecta los componentes principales del
computador (CPU, Memoria e E/S). Un bus del sistema consiste generalmente de
50 a 200 líneas independientes. Estas líneas están clasificadas en tres grupos
funcionales: datos, direcciones y control. Además se dispone del bus de
alimentación para cada módulo.
El bus de datos transmite datos entre módulos. Consta de 8, 16 o 32 líneas (bits)
generalmente, lo que se denomina anchura del bus. Este factor es clave para el
rendimiento del sistema. Por ejemplo, si la anchura del bus es 8, deberá acceder 2
veces a memoria para obtener una instrucción, por una sola vez en el caso de un
bus de 16. El bus de direcciones determina la fuente o destino de los datos del bus
de datos. La anchura del bus de direcciones determina la capacidad máxima de
memoria del sistema. Además, las líneas de este bus se utilizan también para
direccionar los módulos E/S. Generalmente, los bits más significativos se utilizan
para seleccionar un módulo particular del bus y los menos significativos
seleccionan una posición concreta de memoria o un puerto dentro del módulo
seleccionado.
El bus de control se utiliza para controlar el acceso a y el uso de los buses de
datos y direcciones, ya que éstos son compartidos por todos los módulos, por lo
que es necesario establecer un control de los mismos. Las señales de control
transmiten información de comando y sincronización entre módulos. Las señales
más importantes son:

• Escritura en Memoria: el dato presente en el bus de datos se copia en la

dirección de memoria seleccionada.
• Lectura de memoria: el contenido de la dirección seleccionada se transfiere al
bus de datos.
• Escritura E/S: Se saca un dato por un puerto E/S.
• Lectura E/S: Un dato de un puerto E/S seleccionado se transfiere al bus de
datos. • Reconocimiento de transferencia: Indica que se ha aceptado un dato
desde el puerto o escrito en el mismo.
• Petición de Bus: Indica que un módulo solicita el control del bus.
• Reconocimiento de Bus: Indica que el módulo peticionario ha sido habilitado
como controlador del bus.
• Petición de interrupción: Indica que existe una interrupción pendiente de servicio.
• Reconocimiento de interrupción: Indica que la interrupción pendiente ha sido
aceptada.
• Reloj: Usado para sincronizar las operaciones del bus.
• Reset: inicialización de los módulos.
 Conjunto de instrucciones
Un conjunto de instrucciones, repertorio de instrucciones, juego de instrucciones o
ISA (del inglés instruction set architecture, «arquitectura del conjunto de
instrucciones») es una especificación que detalla las instrucciones que una unidad
central de procesamiento puede entender y ejecutar, o el conjunto de todos los
comandos implementados por un diseño particular de una CPU. El término
describe los aspectos del procesador generalmente visibles para un programador,
incluyendo los tipos de datos nativos, las instrucciones, los registros, la
arquitectura de memoria y las interrupciones, entre otros aspectos.

Existen principalmente tres tipos: CISC (Complex Instruction Set Computer), RISC
(Reduced Instruction Set Computer) y SISC (Simple Instruction Set Computing).

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para

distinguir este conjunto de características de la microarquitectura, que son los
elementos y técnicas que se emplean para implementar el conjunto de
instrucciones. Entre estos elementos se encuentran las microinstrucciones y los
sistemas de caché.

Procesadores con diferentes diseños internos pueden compartir un conjunto de

instrucciones; por ejemplo, el Intel Pentium y AMD Athlon implementan versiones
casi idénticas del conjunto de instrucciones x86, aunque tienen diseños diferentes.

El lenguaje máquina
El lenguaje máquina está construido a partir de los estados discretos o
instrucciones. En la arquitectura de procesamiento, una instrucción dada puede
especificar muy bien:

Registros particulares para operaciones aritméticas, de direccionamiento o de

control.
Ubicaciones particulares de la memoria.
Modos de direccionamiento para interpretar a los operandos. ej.
si quieres que el robot cambie un foco quemado Súbete a la escalera, alcanza el
foco, quita el foco quemado, pon el foco nuevo, baja de la escalera, quita la
escalera

Las operaciones más complejas se construyen a partir de estas, que (en una
máquina Von Neumann) se ejecutan secuencialmente, o según el control de flujo.

Muchas o pocas de las operaciones disponibles incluidas en la mayoría de

conjuntos son:

Desplazamiento.
Establecer un registro a un valor constante.
Mover datos desde una posición de memoria a un registro y viceversa. Esto se
realiza para obtener datos para operaciones matemáticas y su almacenamiento.
Leer y escribir datos desde dispositivos de hardware.
Operaciones matemáticas.
Sumar, restar, multiplicar o dividir dos registros y colocar el resultado en alguno de
ellos.
Realizar operaciones bit a bit, teniendo el AND y el OR de cada bit en un par de
registros, o el NOT de cada bit en un registro.
Comparar dos valores que se encuentren en registros(por ejemplo, si son iguales
o si uno es mayor que otro).
Afectan al flujo de programa.
Saltar a otra posición del programa y ejecutar instrucciones allí.
Saltar a otra posición si se cumple cierta condición.
Saltar a otra posición, pero salvando la posición actual para poder volver (realizar
una llamada, por ejemplo call printf).
Algunas computadoras incluyen instrucciones "complejas". Dichas instrucciones
pueden tomar muchas instrucciones en otros equipos. Estas se caracterizan por
instrucciones que necesitan varios pasos, como el control de múltiples unidades
funcionales.

Algunos ejemplos son:

Ahorro de registros en la pila.

Mover grandes bloques de memoria.
Complejas operaciones and/or con aritmética de coma flotante, tales como el seno
o la raíz cuadrada.
Instrucciones que combinan ALU con un operando de la memoria más que de
registros.
Un tipo complejo de la instrucción que ha llegado a ser particularmente popular
recientemente es SIMD (Single Instruction, Multiple Data), una operación que
realice la misma operación aritmética en pedazos múltiples de datos al mismo
tiempo. SIMD tienen la capacidad de manipular vectores y matrices grandes en
tiempo mínimo. Las instrucciones de SIMD permiten la paralelización fácil de los
algoritmos implicados comúnmente en sonido, imagen, y el proceso video. Varias
implementaciones de SIMD se han traído al mercado bajo nombres comerciales
tales como MMX, 3DNow! y AltiVec.

El diseño de sistemas de instrucción es una edición compleja. Había dos etapas

en la historia para el microprocesador. El primer era el CISC (Complex Instruction
Set Computer) que tenía muchas instrucciones diferentes. En los años 1970, IBM
hicieron la investigación y encontraron que muchas instrucciones en el sistema
podrían ser eliminadas. El resultado era el RISC (Reduced Instruction Set
Computer), una arquitectura que utiliza un sistema más pequeño de instrucciones.
Un conjunto de instrucción más simple puede ofrecer el potencial para velocidades
más altas, tamaño reducido del procesador, y consumo de energía reducido. Sin
embargo, un conjunto más complejo puede optimizar operaciones comunes,
mejorar memoria/eficiencia de caché, o simplificar la programación.
 Implementación del conjunto de instrucciones
Cualquier conjunto de instrucciones se puede implementar de varias maneras.
Todas las maneras de implementar un conjunto de instrucciones dan el mismo
modelo programado, y todas pueden hacer funcionar los mismos ejecutables
binarios. Las varias maneras de implementar un conjunto de instrucciones dan
diversas compensaciones entre el coste, el funcionamiento, el consumo de
energía, el tamaño, etc.

Al diseñar microarquitecturas, los ingenieros usaron bloques de circuitos

electrónicos “duramente-conectados” (diseñado a menudo por separado) por
ejemplo, los multiplexores, los contadores, los registros, las ALU, etcétera. Un
cierto tipo del lenguaje de transferencia de registros es a menudo usado para
describir la codificación y la secuencia de cada instrucción de ISA usando esta
microarquitectura física.

Hay también algunos nuevos diseños de CPU que compilan el conjunto de

instrucción a una RAM escribible o FLASH dentro de la CPU (tal como el
procesador Recursiv y el Imsys Cjip), o FPGA (computación reconfigurable).
Western Digital MCP-1600 es un ejemplo antiguo, usando una ROM dedicada,
separada del microcódigo.

ISA se puede también emular en software por un intérprete. Naturalmente, debido

a la interpretación de “overhead”, es más lento que ejecutar programas
directamente sobre el hardware emulado. Hoy, es práctica para los vendedores de
nuevos ISA o microarquitecturas poner emuladores del software a disposición de
los desarrolladores de programas informáticos antes de que la implementación del
hardware esté lista.

Los detalles de la implementación tienen una influencia fuerte en las instrucciones

particulares seleccionadas para el conjunto de instrucción. Por ejemplo, muchas
implementaciones de la instrucción “pipline” permiten solamente una carga de
memoria (load) o almacén en memoria (store) por instrucción, llevando a carga-
almacena arquitectura (RISC). Por otro ejemplo, algunas maneras de implementar
la instrucción “pipline” llevaron a una ranura de retardo.
La demanda de procesamiento de señal digital de alta velocidad han empujado en
el sentido contrario, forzando la implementación de instrucción de manera
particular. Por ejemplo, para realizar los filtros digitales es bastante insuficiente, la
instrucción del MAC en un procesador típico de señal digital (DSP) se debe
implementar usando una arquitectura de Harvard que pueda traer una instrucción
y dos palabras de datos simultáneamente, y requiere un solo ciclo.

Densidad del código

En computadoras antiguas, la memoria del programa era costosa, así que

minimizar el tamaño de un programa para asegurar que va a caber en la memoria
limitada era a menudo central. Así el tamaño combinado de todas las instrucciones
necesitó realizar una tarea particular, la densidad del código, era una
característica importante de cualquier sistema de instrucción. Las computadoras
con alta densidad del código también tenían a menudo instrucciones complejas
para la entrada del procedimiento, los retornos parametrizados, los lazos, etc. Sin
embargo, "instrucciones CISC" combinan simplemente una operación básica de la
ALU, tal como "add", con el acceso de uno o más operandos en memoria (usando
modos de dirección tales como directo, indirecto, indexado). Ciertas arquitecturas
pueden permitir dos o tres operandos (incluido el resultado) directamente en
memoria o pueden permitir realizar funciones tales como el incremento automático
del puntero.

RISC, fueron los primeros implementados con profundidad en el período de rápido

crecimiento de las memorias de subsistemas, se reduce el código con el fin de
simplificar el circuito de aplicación y con ello tratar de aumentar el rendimiento a
través de las frecuencias de reloj más elevadas y el uso de más registros. Las
instrucciones RISC suelen realizar sólo una operación, como una "suma" de
registros o una "carga" de una posición de memoria en un registro, también suelen
utilizar una longitud de instrucciones fijas, mientras que un conjunto de
instrucciones típicas CISC tiene instrucciones muchos más cortas que esta
longitud fija. Las instrucciones de longitud fija son menos complicadas de manejar
que las instrucciones de ancho variable, por varias razones (por ejemplo: no tener
que comprobar si una instrucción se extiende a ambos lados de una línea de
caché o el límite de memoria virtual de la página), y por lo tanto algo más fácil de
optimizar la velocidad . Sin embargo, como los equipos RISC normalmente
requieren más y más para implementar las instrucciones que ejecutan una
determinada tarea, hacen menos óptimo el uso del ancho de banda y de la
memoria caché.

Las computadoras mínimas del conjunto de instrucciones (MISC) son una forma
de máquina apilada, donde hay pocas instrucciones separadas (16-64), para
poder caber instrucciones múltiples en una sola palabra de máquina. Estos tipos
de núcleos llevan a menudo poco silicio para implementarse, así que pueden ser
observadas fácilmente en un FPGA o en una forma multinúcleo. La densidad del
código es similar al RISC; la densidad creciente de la instrucción es compensada
requiriendo más de las instrucciones primitivas de hacer una tarea.

Número de operando

El conjunto de instrucciones puede ser clasificado por el número máximo de

operandos explícitamente especificados en las instrucciones (en los ejemplos que
siguen, a, b y c se refieren a celdas de memoria, mientras que reg1 y sucesivos se
refieren a los registros de la máquina).

0-operando, también llamada máquina de pila: todas las operaciones aritméticas

se ejecutan en la parte superior de una o dos posiciones de la pila, push y pop son
las instrucciones utilizadas para acceder a la memoria: push a, push b, add, pop c.

1-operando (máquinas de una dirección), también llamadas máquinas de

acumulador, incluida en la mayoría de las primeras computadoras y muchos
microcontroladores pequeños: la mayoría de instrucciones especifican un
operando explícito a la derecha (un registro, una posición de memoria, o una
constante) y un operando a la izquierda: load a, add b, store c.

2-operando, la mayoría de las máquinas CISC y RISC entran en esta categoría:

CISC – load a, reg1, add reg1, b; store reg1, c
RISC – cargas que requieren la memoria explícita, las instrucciones serían: load
a,reg1; load b,reg2; add reg1,reg2; store reg2,c
3-operando, permite una mejor reutilización de los datos: CISC - bien una sola
instrucción: add a, b, c, o más generalmente: move a,reg1; add reg1,b,c como la
mayoría de las máquinas se limitan a dos operandos de memoria. RISC - Debido a
la gran cantidad de bits necesarios para codificar los tres registros, este esquema
no suele estar disponible en los procesadores RISC con pequeñas instrucciones
de 16 bits: load a,reg1; load b,reg2; add reg1+reg2->reg3; store reg3,c.

Más operandos, algunas máquinas CISC permiten una variedad de modos de

direccionamiento que permiten más de 3 operandos (registros o accesos a
memoria), como el VAX "POLY", instrucción de evaluación de polinomio.

Características deseables

Las características que se pretende que tenga un conjunto de instrucciones son

cuatro, principalmente:

Completo: que se pueda realizar en un tiempo finito cualquier tarea ejecutable con
un ordenador (computable o decidible).
Eficiente: que permita alta velocidad de cálculo sin exigir una elevada complejidad
en su UC y ALU y sin consumir excesivos recursos (memoria), es decir, debe
cumplir su tarea en un tiempo razonable minimizando el uso de los recursos.
Autocontenidas: esto es, que contengan en sí mismas toda la información
necesaria para ejecutarse.
Independientes: que no dependan de la ejecución de alguna otra instrucción.
Se puede comprobar que para que un conjunto de instrucciones sea completo solo
se necesitan cuatro instrucciones:

Escritura.
Mover a la izquierda una posición y leer.
Mover a la derecha una posición y leer.
Parar.
En esta idea se basan las arquitecturas RISC, no obstante, con este conjunto no
se puede conseguir la eficiencia del repertorio de instrucciones por lo que en la
práctica el conjunto suele ser más amplio en aras de conseguir un mejor
rendimiento, tanto en uso de recursos como en consumo de tiempo.

Tipos de instrucciones y ejemplos

Copian datos de un origen a un destino, sin modificar el origen y normalmente sin
afectar a los flags o indicadores de condición. Pueden transferir palabras,
fracciones de palabras (bytes, media palabra) o bloques completos de n bytes o
palabras.

Estas operaciones pueden ser:

registro a registro.
registro a memoria.
memoria a registro.
memoria a memoria.
Nemotécnicos más frecuentes
move copia el contenido de un registro (o memoria) a otro.
store copia el contenido de un registro a memoria.
load copia el contenido de una posición de memoria a un registro.
move block copia un bloque de datos de una posición de memoria a otra.
move multiple copia del origen en varias posiciones de memoria.
exchange intercambia el contenido de dos operandos.
clear pone a 0 el destinto (todos los bits).
set pone a 1 el destino (todos los bits).
push introduce un dato en la cabecera de la pila (indicada por el SP).
pop saca un dato de la cabecera de la pila (indicada por el SP).

Instrucciones aritméticas

Son efectuadas por la ALU y suelen cambiar los flags o indicadores de condición.
Nemotécnicos más frecuentes

 add: suma.
 add with carry: suma con acarreo.
 subtract: resta.
 subtract with borrow: resta teniendo en cuenta el adeudo anterior.
 increment: incrementa en 1 un valor.
 decrement: decrementa en 1 un valor.
 multiply: multiplica.
 divide: divide.
 extend: aumenta el operando de tamaño.
 negate: cambia de signo.
 absolute: valor absoluto.
Pueden tener instrucciones para tratar con números en BCD e incluyen
operaciones en coma flotante, lo cual se identifica con una 'f' antes del nombre del
nemotécnico como por ejemplo: fabsolute

Instrucciones de comparación

Suelen preceder a una instrucción de bifurcación condicional y modifican los flags.

No hay que pensar que las instrucciones de salto condicional dependen de este
repertorio, ya que lo único que hace el salto condicional es consultar los flags y
salta si precede, pero no depende de ninguna instrucción de comparación. (de
hecho cualquier operación aritmética realizada anteriormente a un salto
condicional puede provocar que este "salte").
Nemotécnicos más frecuentes

 compare: resta los dos operandos pero no almacena el resultado, solo

modifica los flags.
 test: compara un cierto valor especificado con el 0.
Instrucciones lógicas
Realizan operaciones booleanas "bit a bit" entre dos operandos. Como las
aritméticas también modifican los flags.
Nemotécnicos más frecuentes

 and: el "y" lógico.

 or: el "o inclusivo" lógico.
 xor: el "o exclusivo" lógico.
 not: la negación lógica. (complemento a 1, no confundir con el cambio de
signo "negate" que es el complemento a 2).
Instrucciones de desplazamiento
Pueden ser aritmético o lógico y pueden incluir o no rotaciones. Pueden ser de
izquierda a derecha.
Nemotécnicos más frecuentes

 shift: desplazamiento aritmético o lógico.

 rotate: rotación con o sin acarreo.
Instrucciones de bits
Comprueban un bit del operando y su valor lo reflejan en el indicador de cero.
Pueden poner un bit a 0 o complementarlo.
Nemotécnicos más frecuentes

 bit test: comprueba un bit.

 bit clear: comprueba un bit y lo pone a 0.
 bit set: comprueba un bit y lo pone a 1.
Instrucciones de control
Permiten modificar la secuencia normal de ejecución de un programa, puede
hacerse por salto condicional relativo o absoluto.
Se clasifican en cuatro grupos:

1. salto incondicional
2. salto condicional
3. llamada a subrutinas
4. gestión de las interrupciones
Saltos
Pueden ser condicionales o incondicionales, se suelen especificar
como jump o branch, y en el caso de los condicionales se suele
llamar jcond o bcond, donde cond es una o más letras que indican la condición
que ha de cumplirse para que el salto se produzca.
Incondicional
Salta sin comprobar ninguna condición.
Nemotécnicos más frecuentes: jump o branch.
Condicional
Salta si la condición se cumple.
Nemotécnicos más frecuentes: jcond o bcond.
Llamadas a subrutinas
Invoca la ejecución de funciones anteriormente definidas.
Nemotécnicos más frecuentes: call (llamada) y ret (retorno).
Gestión de interrupciones
Se usan para llamar a las rutinas de servicio de interrupción y esto
se puede hacer por hardware o bien por software. Necesita una
instrucción similar a return para retornar al contexto anterior pero
restableciendo el estado de la máquina, para no afectar a la
aplicación a la cual se interrumpió (iret).
Instrucciones de entrada y salida
Son instrucciones de transferencia salvo que el origen/destino de
dicho flujo es un puerto de un dispositivo de entrada y salida. Estas
instrucciones pueden darse mediante dos alternativas:

1. E/S "mapeada" en memoria: los periféricos tienen

direcciones asignadas de la MP por lo que no se necesitan
instrucciones especiales y las operaciones se realizan con
las ya vistas, como son: load, store y move.
2. E/S independiente: necesitan unas instrucciones especiales
para indicarle al procesador que nos estamos refiriendo al
mapa de direcciones de E/S, ya que este mapa y el mapa de
memoria son disjuntos.
Nemotécnicos más frecuentes
  input o read: permite leer información de un puerto y trasladarla
a memoria principal.
 output o write: permite escribir información en un puerto de un
dispositivo.
 test i/o: lee información de control de un periférico.
 control i/o: envía información de control hacia un periférico.
Instrucciones de control y misceláneas
Nemoténicos más frecuentes:

 halt: detiene la ejecución del programa hasta que una

interrupción arranca otro programa.
 wait: sirve para detener la ejecución de un programa hasta que
sucede un determinado evento que no es una interrupción (otra
condición externa al primer programa).
 nop: no realiza ninguna operación, sirve para rellenar huecos en
un programa o temporizar esperas.
 enable: habilita las interrupciones.
 disable: deshabilita las interrupciones.
 test and set: se utiliza para la implementación de la exclusión
mutua, esto es, que un procesador no pueda acceder a un
determinado recurso que está siendo usado por otro procesador
en ese mismo momento.
Se usan como semáforos, esto es, se declara una variable entera
que tendrá el valor 0 si el recurso esta libre y 1 si está siendo
utilizado, de manera que si un procesador comprueba y el semáforo
está en 1 tendrá que esperar hasta que este cambie a 0 (1 =
semáforo rojo y 0 = semáforo verde).

Segmentación de instrucciones

La segmentación de instrucciones es una técnica que permite implementar el paralelismo a

nivel de instrucción en un único procesador. La segmentación intenta tener ocupadas con
instrucciones todas las partes del procesador dividiendo las instrucciones en una serie de
pasos secuenciales que efectuarán distintas unidades de la CPU, tratando en paralelo
diferentes partes de las instrucciones. Permite una mayor tasa de transferencia efectiva por
parte de la CPU que la que sería posible a una determinada frecuencia de reloj, pero puede
aumentar la latencia debido al trabajo adicional que supone el propio proceso de la
segmentación.
Las Unidades Centrales de Procesamiento (CPU) están gobernadas por un reloj.
Cada pulso enviado por el reloj no tiene por qué hacer lo mismo; de hecho, la
lógica de la CPU dirige sucesivos pulsos a distintos lugares para así llevar a cabo
una secuencia que resulte útil. Hay muchos motivos por los que no puede llevarse
a cabo la ejecución de una instrucción al completo en un único paso; cuando se
habla de segmentación, los efectos que no pueden producirse al mismo tiempo se
dividen en pasos separados de la instrucción, pero dependientes entre sí.

Por ejemplo, si un pulso de reloj introduce un valor en un registro o comienza un

cálculo, hará falta cierto tiempo para que el valor sea estable en las salidas del
registro o para que el cálculo se complete. Otro ejemplo: leer una instrucción de
una unidad de memoria no es una operación que pueda hacerse al mismo tiempo
que una instrucción escribe un resultado en la misma unidad de memoria.

Número de pasos

El número de pasos dependientes varían según la arquitectura de la máquina.

Algunos ejemplos:

 Entre 1956 y 1961, el proyecto IBM Stretch proponía los términos Fetch

(Lectura), Decode (Decodificación) y Execute (Ejecución) que se convirtieron
en habituales.

 La segmentación RISC clásica comprende:

1. Lectura de instrucción
2. Decodificación de instrucción y lectura de registro
3. Ejecución
4. Acceso a memoria
5. Escritura de vuelta en el registro

 Las microcontroladoras Atmel AVR y PIC disponen cada una de

segmentación de dos etapas.
 Muchos diseños incluyen segmentación de 7, 10 e incluso 20 etapas (como
es el caso del Pentium 4 de Intel).

 Los núcleos "Prescott" y "Cedar Mill" de la microarquitectura NetBurst de

Intel, utilizados en las versiones más recientes del Pentium 4 y sus
derivados Pentium D y Xeon, tienen una segmentación de 31 etapas.

 El "Xelerated X10q Network Processor" cuenta con una segmentación de

más de 1000 etapas, si bien en este caso 200 de estas etapas representan
CPU independientes con instrucciones programadas de forma individual. Las
etapas restantes se usan para coordinar los accesos a la memoria y las
unidades funcionales presentes en el chip.1
Conforme la segmentación se hace más "profunda" (aumentando el número de
pasos dependientes), un paso determinado puede implementarse con circuitería
más simple, lo cual puede permitir que el reloj del procesador vaya más rápido. 2
En inglés, las segmentaciones de este tipo pueden llamarse superpipelines.3
Se dice que un procesador está totalmente segmentado si puede leer una
instrucción en cada ciclo. Por tanto, si ciertas instrucciones o condiciones
requieren un retardo que impide la lectura de nuevas instrucciones, el procesador
no está totalmente segmentado.

Peligros
El modelo de la ejecución secuencial asume que cada instrucción se completa
antes de que comience la siguiente; esta suposición no es cierta en el caso de un
procesador segmentado. Una situación donde el resultado esperado es
problemático se denomina peligro. Imaginemos las siguientes dos instrucciones
actuando sobre los registros de un procesador hipotético:

Si el procesador dispone de las 5 etapas mostradas en la ilustración inicial de este

artículo, la instrucción 1 se leería en el momento t1 y su ejecución se completaría
en t5, mientras que la instrucción 2 se leería en t2 y se completaría en t6. La
primera instrucción podría depositar el número incrementado en R5 como su
quinto paso (escritura de vuelta al registro) en t5. Pero la segunda instrucción
podría obtener el número de R5 (que se dispone a copiar a R6) en su segundo
paso (decodificación de instrucción y lectura de registro) en el momento t3. Parece
que la primera instrucción no habrá todavía incrementado para entonces su valor;
tenemos, por lo tanto, un peligro.

Escribir programas informáticos en un lenguaje compilado podría no dar pie a este

tipo de preocupaciones, ya que el compilador podría estar diseñado para generar
código máquina que evita los peligros.

Medidas cautelares

En algunos de los primeros DSP y procesadores RISC, la documentación

aconsejaba a los programadores evitar este tipo de dependencias en instrucciones
adyacentes o cuasi-adyacentes (llamadas huecos de retardo), o declaraba que la
segunda instrucción usaba un valor antiguo en lugar del valor deseado (en el
ejemplo de arriba, el procesador podría limitarse a copiar el valor todavía sin
incrementar), o declaraba que el valor usado no está definido. El programador
podría tener otras cosas que ordenarle hacer al procesador mientras tanto; o bien,
para asegurar los resultados correctos, el programador podía insertar NOPs en el
código, lo cual por otro lado iba en contra de las ventajas que aporta la
segmentación.

Soluciones

Los procesadores segmentados suelen utilizar tres técnicas para funcionar como
se espera de ellos cuando el programador da por sentado que cada instrucción se
completa antes de que comience la siguiente:

 Los procesadores que pueden computar la presencia de un peligro

pueden frenarse, retardando el procesamiento de la segunda instrucción (y
posteriores) hasta que los valores que necesita como entrada están listos para
usarse. Esto crea una burbuja en la segmentación, y también va a la contra de
las ventajas que aporta la segmentación.
 Algunos procesadores pueden no solo computar la presencia de un peligro
sino también compensar ese factor contando con rutas de datos adicionales
que proporcionan las entradas necesarias para un paso de la computación
antes de que una instrucción posterior ejecute esos pasos; es un atributo
denominado reenvío de operandos.

 Algunos procesadores pueden determinar que las instrucciones aparte de la

siguiente de la secuencia no dependen de las instrucciones actuales, y que
pueden ejecutarse sin que surja ningún peligro. Tales procesadores pueden
realizar ejecución fuera de orden.

Ramas

A menudo, una ramificación saliente de la secuencia normal de instrucciones está

relacionada con un peligro. A menos que el procesador pueda llevar a afecto la
rama en un único ciclo de reloj, la segmentación continuará leyendo instrucciones
de forma secuencial. No puede permitirse que tales instrucciones se lleven a
afecto porque el programador ha pasado el control a otra parte del programa.

Una rama condicional es si cabe todavía más problemática. El procesador puede o

no ramificar, dependiendo de un cálculo que todavía no ha tenido lugar. Puede
darse el caso de que varios procesadores se frenen, intenten hacer una predicción
de salto, o puedan empezar a ejecutar dos secuencias distintas del programa
(ejecución ansiosa), en ambos casos asumiendo que la rama se ha tomado y no
se ha tomado, descartando todo el trabajo que corresponde a la suposición
incorrecta.6

Un procesador con una implementación de un predictor de saltos que

normalmente realiza predicciones acertadas puede minimizar la penalización en el
rendimiento que supone la ramificación. Sin embargo, si la predicción de los saltos
se equivoca con excesiva frecuencia, esto puede crear más trabajo para el
procesador, que tiene que quitar de la segmentación la ruta incorrecta de código
que ha comenzado a ejecutarse, antes de poder continuar la ejecución en la
posición correcta.
Los programas escritos para un procesador segmentado evitan de forma
deliberada las ramificaciones para minimizar las posibles pérdidas de velocidad.
Por ejemplo, el programador puede encargarse de los casos habituales con
ejecución secuencial, y usar ramificaciones sólo al detectar casos poco frecuentes.
El uso de programas como gcov para analizar la cobertura de código permite al
programador medir la frecuencia con la que se ejecutan determinadas ramas, y
obtener así información añadida que le permita optimizar el código.

Programas auto-modificables

La técnica del código automodificable puede resultar problemática en un

procesador segmentado. Al emplear esta técnica, uno de los efectos de un
programa es la modificación de sus propias instrucciones subsiguientes. Si el
procesador cuenta con un caché de instrucciones, la instrucción original puede
haber sido ya copiada a una cola de entrada de prelectura, y la modificación no
tendrá efecto.

Instrucciones no interrumpibles

Una instrucción puede ser no interrumpible para asegurar su atomicidad, por

ejemplo cuando intercambia dos elementos. Un procesador secuencial permite
interrupciones entre las instrucciones, pero un procesador segmentado yuxtapone
las instrucciones, con lo cual ejecutar una instrucción no interrumpible hace que
partes de las instrucciones ordinarias sean no interrumpibles también. La
segmentación tiene ocupadas todas las partes que conforman el procesador e
incrementa la cantidad de trabajo útil que éste puede realizar en un determinado
espacio de tiempo. Lo habitual es que la segmentación reduzca el tiempo de los
ciclos del procesador e incremente la tasa de transferencia efectiva de
instrucciones. Las ventajas en cuanto a velocidad disminuyen cuando la ejecución
se encuentra con peligros que requieren que ésta reduzca su velocidad por debajo
de la tasa ideal. Un procesador no segmentado sólo ejecuta una instrucción cada
vez. El comienzo de la siguiente instrucción no se retrasa por la aparición de
peligros, sino incondicionalmente.
La necesidad de un procesador segmentado de organizar todo su trabajo en
pasos modulares puede requerir la duplicación de registros, lo cual incrementa la
latencia de algunas instrucciones.

Economía
Al simplificar cada uno de los pasos, la segmentación puede hacer posibles las
operaciones complejas de forma más económica que añadiendo circuitería
compleja, por ejemplo para los cálculos numéricos. Por otra parte, un procesador
que rehúsa perseguir un aumento en la velocidad recurriendo a la segmentación
puede ser más sencillo y barato de fabricar.

Predecibilidad
En comparación con entornos donde el programador tiene que evitar los peligros o
buscar la forma de soslayarlos, el uso de un procesador no segmentado puede
hacer más fácil la programación y la propia tarea de formar a los programadores.
El procesador no segmentado también hace más fácil predecir la sincronización
exacta de una secuencia determinada de instrucciones.

Consideraciones de diseño
Velocidad
La segmentación tiene ocupadas todas las partes que conforman el procesador e
incrementa la cantidad de trabajo útil que éste puede realizar en un determinado
espacio de tiempo. Lo habitual es que la segmentación reduzca el tiempo de los
ciclos del procesador e incremente la tasa de transferencia efectiva de
instrucciones. Las ventajas en cuanto a velocidad disminuyen cuando la ejecución
se encuentra con peligros que requieren que ésta reduzca su velocidad por debajo
de la tasa ideal. Un procesador no segmentado sólo ejecuta una instrucción cada
vez. El comienzo de la siguiente instrucción no se retrasa por la aparición de
peligros, sino incondicionalmente.
La necesidad de un procesador segmentado de organizar todo su trabajo en
pasos modulares puede requerir la duplicación de registros, lo cual incrementa la
latencia de algunas instrucciones.

Economía
Al simplificar cada uno de los pasos, la segmentación puede hacer posibles las
operaciones complejas de forma más económica que añadiendo circuitería
compleja, por ejemplo para los cálculos numéricos. Por otra parte, un procesador
que rehúsa perseguir un aumento en la velocidad recurriendo a la segmentación
puede ser más sencillo y barato de fabricar.

Predecibilidad
En comparación con entornos donde el programador tiene que evitar los peligros o
buscar la forma de soslayarlos, el uso de un procesador no segmentado puede
hacer más fácil la programación y la propia tarea de formar a los programadores.
El procesador no segmentado también hace más fácil predecir la sincronización
exacta de una secuencia determinada de instrucciones.

Ejemplo ilustrado
A la derecha tenemos una segmentación genérica con cuatro etapas: lectura,
decodificación, ejecución y escritura. La caja gris de la parte de arriba es la lista de
instrucciones que esperan a ser ejecutadas, la caja gris de abajo es la lista de
instrucciones que han completado su ejecución, y finalmente la caja blanca central
es la segmentación en sí.

La ejecución procede del modo siguiente:

Ilustración 16 Ejecucion reloj
 Ilustración 17 Segmentación genérica de 4 etapas

Burbuja en la segmentación

Un procesador segmentado puede enfrentarse a los peligros frenando y creando

una burbuja en la segmentación, lo cual se traduce en uno o más ciclos en los que
no ocurre nada útil.

En la ilustración de la derecha, en el ciclo 3, el procesador no puede decodificar la

instrucción lila, quizá porque el procesador ha determinado que la decodificación
depende de los resultados producidos por la ejecución de la instrucción verde. La
instrucción verde puede proceder a su fase de ejecución y luego a la de escritura
tal como estaba previsto, pero la instrucción lila se ve retrasada un ciclo entero en
la fase de lectura. La instrucción azul, que iba a ser leída durante el ciclo 3,
también se ve retrasada un ciclo, y lo mismo le ocurre a la instrucción roja que la
sigue.

Por culpa de la burbuja (los círculos azules de la ilustración), la circuitería de

decodificación del procesador no hace nada durante el ciclo 3, lo mismo que le
ocurre a la circuitería de ejecución durante el ciclo 4 y a la de escritura durante el
ciclo 5.

Cuando la burbuja finalmente sale de la segmentación (en el ciclo 6), la ejecución

normal continúa, pero ahora todo ocurre con un ciclo de retraso. Se tardará 8
ciclos (del 1 al 8) en lugar de 7 en ejecutar completamente las cuatro instrucciones
mostradas en colores.

Ilustración 18 Una burbuja en el ciclo 3 retarda la ejecución

Los usos históricamente más significativos de la segmentación fueron con el

proyecto ILLIAC II y con el proyecto IBM Stretch, aunque ya se usó antes una
versión más sencilla en el Z1 en 1939 y en el Z3 en 1941.7

La segmentación empezó a popularizarse a finales de los 70 en las

supercomputadoras en forma de procesadores vectoriales y de matrices. Una de
las primeras supercomputadoras fue la serie Cyber construida por Control Data
Corporation. Su principal arquitecto, Seymour Cray, dirigió posteriormente Cray
Research. Cray desarrolló la línea XMP de supercomputadoras, usando
segmentación para las funciones tanto de multiplicación como de suma y
sustracción. Posteriormente, Star Technologies añadió el paralelismo (varias
funciones segmentadas trabajando en paralelo), desarrollado por Roger Chen. En
1984, Star Technologies añadió el circuito de división segmentado desarrollado
por James Bradley. A mediados de los 80, la supercomputación estaba al alcance
de muchas empresas de todo el mundo.

La segmentación no estaba limitada a supercomputadoras. En 1976, la serie 470

del mainframe de propósito general de la Corporación Amdahl tenía una
segmentación de 7 etapas, y un circuito de predicción de saltos patentado.

En la actualidad, la segmentación y la mayoría de innovaciones aquí descritas

forman parte de la unidad de instrucciones de la mayoría de los
microprocesadores.

Ciclo de instrucción

Un ciclo de instrucción (también llamado ciclo de fetch-and-execute o ciclo de

fetch-decode-execute en inglés) es el período que tarda la unidad central de
proceso (CPU) en ejecutar una instrucción de lenguaje máquina.

Comprende una secuencia de acciones determinada que debe llevar a cabo la

CPU para ejecutar cada instrucción en un programa. Cada instrucción del juego de
instrucciones de una CPU, puede requerir diferente número de ciclos de
instrucción para su ejecución. Un ciclo de instrucción está formado por uno o más
ciclos máquina.

Para que cualquier sistema de proceso de datos basado en microprocesador (por

ejemplo un ordenador) o microcontrolador (por ejemplo un reproductor de MP3)
realice una tarea (programa) primero se debe buscar cada instrucción en la
memoria principal y luego ejecutarla.
 Secuencia de acciones del ciclo de instrucción
Habitualmente son cuatro los cuales son:

1. Buscar la instrucción en la memoria principal

Se vuelca el valor del contador de programa sobre el bus de
direcciones. Entonces la CPU pasa la instrucción de la memoria
principal a través del bus de datos al Registro de Dirección de
Memoria (MAR). A continuación el valor del MAR es colocado en el
Registro de Instrucción Actual (CIR), un circuito que guarda la
instrucción temporalmente de manera que pueda ser decodificada y
ejecutada.

2. Decodificar la instrucción

El decodificador de instrucción interpreta e implementa la instrucción.

El registro de instrucción (IR) mantiene la instrucción en curso
mientras el contador de programa (PC, program counter) guarda la
dirección de memoria de la siguiente instrucción a ser ejecutada.

Recogida de datos desde la memoria principal

Se accede al banco de registros por los operandos (solo si es
necesario)
Se calcula el valor del operando inmediato con extensión de signo
(solo si es necesario)
También se lee la dirección efectiva de la memoria principal si la
instrucción tiene una dirección indirecta, y se recogen los datos
requeridos de la memoria principal para ser procesados y colocados
en los registros de datos.

3. Ejecutar la instrucción

A partir del registro de instrucción, los datos que forman la

instrucción son decodificados por la unidad de control. Ésta
interpreta la información como una secuencia de señales de control
que son enviadas a las unidades funcionales relevantes de la CPU
para realizar la operación requerida por la instrucción poder
terminarla y seguir asi.
 4. Almacenar o guardar resultados
El resultado generado por la operación es almacenado en la
memoria principal o enviado a un dispositivo de salida dependiendo
de la instrucción. Basándose en los resultados de la operación, el
contador de programa se incrementa para apuntar a la siguiente
instrucción o se actualiza con una dirección diferente donde la
próxima instrucción será recogida.

El ciclo de búsqueda
Los pasos 1 y 2 del ciclo de instrucción se conocen como ciclo de
búsqueda. El ciclo de búsqueda procesa la instrucción a partir de la
palabra de instrucción, que contiene el código de operación y el
operando.

El ciclo de ejecución
Los pasos 3 y 4 del ciclo de instrucción se conocen como ciclo de
ejecución. Estos pasos cambiarán con cada tipo de instrucción.

El primer paso del ciclo de ejecución

Es el proceso de memoria, en que los datos se transfieren entre la
CPU y el módulo de entrada/salida (I/O). A continuación se produce
el proceso de datos, que usa operaciones aritméticas así como
lógicas en referencia a los datos. Después tiene lugar el paso de
alteraciones centrales, que son una secuencia de operaciones, por
ejemplo una operación de salto. El último paso es una operación
combinada de todos los otros pasos.

Ante la necesidad de realizar un programa, podemos conectar los componentes

(sumadores, desplazadores, memorias, etc.) de forma que realicen determinadas
funciones. Esto es conocido como 'hardwired program' o lógica cableada. No
obstante, podemos diseñar una configuración hardware de propósito general que
realizara funciones aritméticas y lógicas. Con la primera aproximación, el sistema
acepta datos y produce resultados. Con la segunda, el sistema acepta datos y
señales de control y produce resultados, por lo que para cambiar el programa sólo
se necesita proporcionar al sistema un nuevo conjunto de señales de control.

Hardware ‘a medida’

Datos Secuencia de funciones Resultados

Aritméticas y Lógicas

Códigos de Instrucción

Intérprete de Instrucciones

Señales de Control

Datos Funciones aritmético-lógicas Resultados

De propósito general

FIGURA 1.1. Aproximaciones hardware y software.

La forma de generar estas señales de control, que serían distintas en cada paso
de programa, puede hacerse mediante un código único para cada posible conjunto
de señales, y añadir entonces al hardware de propósito general un segmento que
acepte estos códigos y genere las señales de control adecuadas. Estos códigos
son básicamente las instrucciones que acepta el hardware, y el conjunto de estas
instrucciones sería el software del sistema.

El módulo que implementa las funciones aritmético-lógicas junto con el

intérprete de las instrucciones constituyen la CPU del sistema. La necesidad de
introducir los datos y almacenar o visualizar los resultados nos llevan a la
necesidad de un sistema de E/S. Por último, debido a que los programas
necesitan acceder a datos, se necesita una memoria que almacene la información
y a la que se pueda acceder en cualquier posición.

Así pues, desde un punto de vista de máxima abstracción, un computador

consiste en una CPU, memoria y componentes de E/S, con uno o más módulos de
cada tipo. Estos componentes se interconectan de alguna forma para obtener la
función básica del computador, que es ejecutar programas.

Un microprocesador es básicamente una ALU y una unidad de control integrada

en el mismo chip. Un microcomputador combina un microprocesador con memoria
y unidades de entrada/salida de datos. En la figura se muestra la evolución de los
µP.

• µP DE 4 BITS: Construidos con tecnología PMOS debido a su bajo coste.

Estos µP se siguen utilizando para aplicaciones de bajo coste industriales y de
consumo.
• BIT-SLICES: utilizados para aplicaciones que requieran gran potencia de
computación. Se trata de módulos idénticos que contienen CPUs con datos de
pocos bits (típicamente 4). Su disposición en paralelo permite conseguir CPU
de longitudes de palabra múltiplos de la básica, con la ventaja de estar
realizados con tecnologías rápidas (TTL, ECL), aprovechando la estructura
simplificada de cada módulo que no requiere un alto grado de integración. Su
uso ha disminuido con la aparición de µP de longitudes de palabra mayores.

• µP DE 8 BITS: La segunda generación de µP comenzó en 1972 con el 8008

de Intel. La tecnología NMOS fue adoptada en 1974, permitiendo incrementar
sus funciones y velocidad.
Posteriormente fueron desarrollándose procesadores de periféricos para estos
dispositivos que soportaban otras funciones de control tales como CRT y
unidades de disco. Los µP actuales de 8 bits utilizan generalmente palabras
internas de longitud 16 o 32 bits (por ejemplo, el Intel 8088 y el Motorola 6809).
Básicamente representan versiones de µP de 16 o
32 bits para aplicaciones de bajo coste.

• µP DE 16 BITS: El PACE de National Semiconductor fue el primer µP de 16

bits (1974) con el. El Intel 8086 aparece en 1978, el Zilog Z8000 en 1979 y el
Motorola 68000 en 1980. Utilizan tecnología NMOS mejorada (XMOS, HMOS,
etc). Las principales novedades que introducen son:

• Modos de operación protegidos (modo de sistema y modo normal, lo que

permite que un programa supervisor, como un sistema operativo, pueda
realizar funciones prohibidas generalmente a aplicaciones del usuario).
• Segmentación y protección de memoria.

• µP DE 32 BITS: El primer µP de 32 bits, el Intel APX 432, aparece en 1981.

Existen otros procesadores posteriores que son básicamente versiones de 32
bits de modelos anteriores o que mantienen cierta compatibilidad con aquéllos
(68020, 80386, etc.). Como características podemos destacar:
• Mayores densidades de integración y velocidades de reloj → Incremento de la
velocidad de proceso.
• Optimización de arquitecturas: pipe-lines de 3 o más etapas, unidades de
control de memoria integradas en el mismo chip, coprocesadores de coma
flotante integrados, etc.
• Nuevas técnicas de manejo de memoria virtual: paginación y técnicas mixtas
paginación-segmentación.

• DSP (Procesadores Digitales de Señal): microprocesadores de uso específico

optimizados para realizar procesado digital de señal en tiempo real. El primer
DSP fue el Intel 2920.

Estructuras de Interconexión

El conjunto de caminos de interconexión entre los distintos módulos del

computador se denomina 'estructura de interconexión'. De los diferentes tipos de
estructuras de interconexión, la más usual es la interconexión de bus, que es la
única que comentaremos en esta introducción, ya que básicamente es la misma
que se implementa a nivel interno de la CPU para interconexión de sus elementos
constituyentes.

ESTRUCTURA DE BUS

Se denomina 'bus del sistema' al bus que conecta los componentes principales
del computador (CPU, Memoria e E/S). Un bus del sistema consiste generalmente
de 50 a 200 líneas independientes. Estas líneas están clasificadas en tres grupos
funcionales: datos, direcciones y control. Además se dispone del bus de
alimentación para cada módulo.

El bus de datos transmite datos entre módulos. Consta de 8, 16 o 32 líneas (bits)

generalmente, lo que se denomina anchura del bus. Este factor es clave para el
rendimiento del sistema. Por ejemplo, si la anchura del bus es 8, deberá acceder 2
veces a memoria para obtener una instrucción, por una sola vez en el caso de un
bus de 16.

El bus de direcciones determina la fuente o destino de los datos del bus de datos.
La anchura del bus de direcciones determina la capacidad máxima de memoria
del sistema. Además, las líneas de este bus se utilizan también para direccionar
los módulos E/S. Generalmente, los bits más significativos se utilizan para
seleccionar un módulo particular del bus y los menos significativos seleccionan
una posición concreta de memoria o un puerto dentro del módulo seleccionado.

El bus de control se utiliza para controlar el acceso a y el uso de los buses de

datos y direcciones, ya que éstos son compartidos por todos los módulos, por lo
que es necesario establecer un control de los mismos. Las señales de control
transmiten información de comando y sincronización entre módulos. Las señales
más importantes son:
• Escritura en Memoria: el dato presente en el bus de datos se copia en la
dirección de memoria seleccionada.
• Lectura de memoria: el contenido de la dirección seleccionada se
transfiere al bus de datos.
• Escritura E/S: Se saca un dato por un puerto E/S.
• Lectura E/S: Un dato de un puerto E/S seleccionado se transfiere al bus
de datos.
• Reconocimiento de transferencia: Indica que se ha aceptado un dato
desde el puerto o escrito en el mismo.
• Petición de Bus: Indica que un módulo solicita el control del bus.
• Reconocimiento de Bus: Indica que el módulo peticionario ha sido
habilitado como controlador del bus.
• Petición de interrupción: Indica que existe una interrupción pendiente de
servicio.
• Reconocimiento de interrupción: Indica que la interrupción pendiente ha
sido aceptada.
• Reloj: Usado para sincronizar las operaciones del bus.
• Reset: inicialización de los módulos.
 CPU MEMORIA

BUS DIRECCIONES

BUS DATOS

BUS CONTROL

E/S

FIGURA 1.2. Estructura de interconexión de bus.

El bus opera de la siguiente forma:

• Un módulo desea enviar datos a otro: 1) obtiene el uso del bus; 2)

transfiere los datos a través del bus.
• Un módulo desea obtener datos de otro módulo: 1) Obtiene el uso del
bus; 2) solicita la transferencia al otro módulo mediante las líneas de
dirección y control apropiadas, y esperar hasta el envío de los datos
desde el otro módulo.

Físicamente, el bus del sistema consiste en conductores eléctricos paralelos,

dispuestos en la placa de c.i., y que se extiende a todos los componentes del
sistema, cada uno de los cuales se conecta a algunas o a todas las líneas del bus.
Una forma usual y económica de implementar este tipo de bus es conectar a él
diferentes placas que contienen los módulos, lo que hace al sistema fácilmente
expansible sin más que añadir nuevas placas, a la vez que facilita la
determinación de fallos.

Funcionamiento de la Unidad Central de Proceso

La CPU lee ('fetch') instrucciones de la memoria (una cada vez), la ejecuta y

busca la siguiente, ininterrumpidamente. El procesamiento de una instrucción se
denomina 'ciclo de instrucción' como se muestra en la figura. El proceso se
interrumpe sólo si la máquina es desconectada, ocurre algún tipo de error o se
encuentra una instrucción HALT.

Comienzo

Búsqueda
Ciclo Búsqueda Siguiente
Instrucción

Ejecución
Ciclo Ejecución Instrucción

HALT

FIGURA 1.3. Ciclo básico de instrucción.

CICLO DE BUSQUEDA Y EJECUCION.

 La búsqueda de instrucción se realiza secuencialmente, si no se especifica lo
contrario. La instrucción buscada está codificada en binario y especifica la acción
a realizar por la CPU. La CPU interpreta esta instrucción e implementa las
siguientes funciones:

• CPU-Memoria: transferencia de datos en cualquiera de los sentidos.

• CPU-E/S: transferencia de datos con módulos de entrada/salida.

• Procesado de datos: implementación de operaciones aritméticas y/o

lógicas.

• Control: control del flujo del programa, a través de saltos en la búsqueda

de nuevas instrucciones motivados por resultados y órdenes anteriores.

Para algunas instrucciones, pueden necesitarse más de un acceso a memoria y

de accesos a E/S. El caso más general de un ciclo de instrucción puede
representarse como un diagrama de estados, algunos de los cuales pueden ser
nulos y algunos pueden ejecutarse más de una vez para una instrucción
determinada.

Acceso
CPU a BI BO AR
Memoria
o E/S

Operandos Múltiples
Múltiples Resultados

Operación
Interna CDI DCO CDO EO CDR
CPU

Siguiente Instrucción
 FIGURA 1.4. Diagrama de estados del ciclo de instrucción.

• Cálculo.dirección.instrucción (cdi): Determina la dirección de la siguiente

instrucción a ejecutar. Generalmente supone sumar 1 a la dirección de
la instrucción previa.

• Búsqueda.instrucción (bi): transfiere la instrucción desde memoria a la

CPU.
• Decodificación.código.operación (dco): analiza la instrucción para
determinar el tipo de operación a ejecutar y los operandos necesarios.

• Cálculo.dirección.operandos (cdo): si la operación hace referencia a un

operando almacenado en memoria o accesible via E/S, se determina la
dirección del operando.

• Búsqueda.operando (bo): transferencia del operando desde memoria o

E/S.

• Ejecución.operación (eo): realiza la operación indicada.

• Cálculo.dirección.resultado (cdr): si la operación hace referencia a un

resultado a almacenar en memoria o accesible vía E/S, se determina la
dirección del resultado.

• Almacenamiento.resultado (ar): escribe el resultado en memoria o E/S.

Los estados de la parte superior del diagrama están relacionados con un

intercambio entre la CPU y memoria o E/S, mientras que los de la inferior se
refieren a operaciones internas de la CPU.

CICLO DE INTERRUPCION.

Las interrupciones, que implican un mecanismo por el cual se interrumpe el

procesado normal de la CPU, responden a la necesidad de incrementar la
eficiencia de procesado. En algunos casos, la CPU está conectada a dispositivos
de E/S lentos. En estos casos conviene que la CPU no esté sirviendo
continuamente al periférico, sino que éste avise de cuándo ha terminado la
operación anterior y está listo para recibir otra. Este aviso se realiza a través de
una señal de petición de interrupción ('interrupt request'), a lo que la CPU
responde interrumpiendo el programa en curso, saltando a un subprograma de
servicio al periférico, y reasumiendo la ejecución original posteriormente.

Para acomodar las interrupciones, es necesario añadir un ciclo de interrupción.

En este ciclo, la CPU comprueba si se ha producido alguna interrupción. Si no se
ha producido, se continúa con la siguiente instrucción. Si se ha producido, se
ejecutan los siguientes pasos:

1. Guarda el contexto del programa actualmente en ejecución. Esto significa

guardar la dirección de la siguiente instrucción a ejecutar y cualquier otro dato
relevante para la CPU.

2. La siguiente instrucción a ejecutar se bifurca al programa de servicio de

interrupción. Cuando se termina de ejecutar este programa, se recupera el
contexto anterior.

BI BO AR

Operandos Múltiples
Múltiples Resultados

Test
CDI DCO CDO EO CDR INT
NO SI

INT
Siguiente Instrucción

FIGURA 1.5. Ciclo de instrucción con interrupciones.

 Las interrupciones no siempre se sirven inmediatamente. La CPU puede
deshabilitar o habilitar todas o algunas líneas de interrupción. Generalmente,
mientras se está sirviendo una, se suelen deshabilitar para evitar interrupciones
anidadas.

Estructura del Procesador

Para comprender la organización de la CPU, consideremos los requerimientos

exigidos:

• Buscar instrucciones: lectura de memoria.

• Interpretar instrucciones: decodificación para determinar acciones a
realizar.
• Buscar datos: lectura de datos de memoria y/o E/S.
• Procesar datos: implementar operaciones aritméticas o lógicas.
• Escribir resultados: sobre memoria y/o E/S.

Para realizar estas funciones, la CPU necesita almacenar temporalmente datos:

debe memorizar la posición de la última instrucción para determinar la siguiente y
contener los operandos mientras se ejecutan las instrucciones. Esta memoria
interna a la CPU estará compuesta por los registros.
En la siguiente figura se muestra una estructura interna de la CPU. Además
de los componentes básicos ya presentados (ALU y UC), comprende los caminos
de transferencia de datos y de control, incluyendo el bus interno, necesario para
transferir datos entre los diferentes registros y la ALU, puesto que ésta opera sólo
con datos contenidos en registros, no con memoria externa. Existe, pues, una
similaridad entre la estructura interna de la CPU y la estructura externa del
computador: en ambos casos existen unas unidades funcionales conectadas entre
ellas por caminos o buses.

En los siguientes apartados estudiaremos la estructura de estos bloques

funcionales: Registros, ALU y Unidad de Control, así como el tipo de operaciones
que ejecuta la CPU y el control de las mismas.
 ALU REGISTROS

Bus interno
Bus control

UNIDAD
Señales control CONTROL Señales control

Figura 1.6. Estructura interna de la CPU.

Organización de Registros.

Los registros en la CPU sirven para dos funciones:

• Registros visibles para el usuario: permiten al programador minimizar las

referencias a la memoria principal mediante la optimización de su uso.

• Registros de control y estado: son utilizados por la unidad de control para

controlar la operación de la CPU y por los programas del sistema
operativo para controlar la ejecución de programas.

REGISTROS VISIBLES PARA EL USUARIO.

Un registro visible para el usuario es aquél que puede referenciarse por medio del
lenguaje máquina que la CPU ejecuta. Se pueden caracterizar en las siguientes
categorías:
 • Propósito general.
• Datos.
• Direcciones.
• Códigos condicionales.

Los registros de propósito general son utilizados por el programador para

diversas funciones. En principio cualquier registro puede utilizarse para contener
el operando de cualquier instrucción. No obstante, pueden existir restricciones (por
ejemplo, pueden existir registros para operaciones en coma flotante).

En algunos casos, estos registros pueden utilizarse para funciones de

direccionamiento (por ejemplo, desplazamiento, indirecto por registro). En otros
casos, existe una distinción clara entre registros de datos y direcciones. Los
primeros sólo pueden contener datos, mientras que los segundos pueden ser
también de propósito general o estar dedicados a un modo particular de
direccionamiento. Por ejemplo:

• Punteros de segmento: en máquinas con direccionamiento segmentado,

un registro segmento contiene la dirección de la base del segmento.
Puede haber múltiples registros, por ejemplo uno para el sistema
operativo y otro para el proceso actual.
• Registros índice: Se utilizan para direccionamiento indexado y pueden
ser autoindexados.
• Puntero de pila: si existe direccionamiento por pila visible al usuario, el
pila está generalmente en memoria y hay un registro dedicado que
apunta a la cima. Esto permite direccionamiento implícito.

Con el uso de registros especializados, pueden estar implícitos en el código

de operación, ahorrando bits del especificador, que sólo deberá distinguir uno
entre un conjunto determinado y no uno de entre todos los registros. No obstante,
la excesiva especialización limita la flexibilidad del programador.

El número de registros afecta también al conjunto de instrucciones ya que son

necesarios más bits de la instrucción para seleccionar el registro. En máquinas
convencionales, el óptimo suele estar entre 8 y 32.

La longitud del registro es otro factor importante. Los registros de direcciones

deben ser al menos de igual longitud que la dirección a seleccionar. Los de datos
pueden trabajar con longitudes diferentes, por lo que en ocasiones se disponen
contiguos para usarlos con valores de doble longitud.

Existe una gran variedad de organización de registros, dependiendo de la

máquina, pero hay cuatro registros que son básicos para la ejecución de una
instrucción:

• Contador de programa (PC): contiene la dirección de la instrucción a

buscar. Es incrementado generalmente por la CPU después de cada
búsqueda, por lo que siempre apunta a la siguiente instrucción a
ejecutar.
• Registro de instrucciones (IR): contiene la última instrucción buscada. La
instrucción es analizada a nivel de código y operandos.
• Registro de dirección de memoria (MAR): contiene la dirección de una
posición de memoria. Se utiliza para la búsqueda de instrucciones y/o
operandos. Está conectado al bus de direcciones.
• Registro buffer de memoria (MBR): contiene un dato leído de memoria o
a escribir en ella. Está conectado al bus de datos y los registros
intercambian datos con memoria a través de él.

Internamente, los datos deben acceder a la ALU para realizar operaciones. La

ALU puede tener acceso directo al MBR y a los registros, o bien puede disponer
de registros buffer adicionales, que sirven como registros entrada/salida a la ALU
e intercambian datos con MBR y registros.

Los registros de códigos de condición o estado contienen flags que son activados
por la CPU como resultado de operaciones. El código puede ser testado
posteriormente para operaciones de salto condicional. En general, pueden ser
leídos, pero no modificados directamente por el programador. Todas las CPU
incluyen uno o varios de este tipo de registros, conocidos como 'palabra de estado
de programa (PSW)'. Los indicadores más usuales son:

• Signo: contiene bit de signo de la última operación realizada.

• Cero: '1' cuando el resultado es 0.
• Acarreo: '1' cuando se produce un sobrepasamiento del último bit como
resultado de una operación. Utilizado en operaciones aritméticas de
precisión extendida.
• Igual: '1' cuando una comparación lógica es igual.
 • Sobrepasamiento: indica overflow aritmético.
• Habilitación interrupción: habilita o deshabilita interrupciones.
• Supervisor: Indica cuándo la CPU está trabajando en modo supervisor o
usuario. Algunas instrucciones privilegiadas y algunas áreas de memoria
sólo pueden utilizarse en modo supervisor.

Unidad Aritmético Lógica

La Unidad Aritmético-Lógica (ALU) es el elemento funcional de la CPU

encargada de la ejecución de instrucciones. Dicha ejecución viene determinada
por las órdenes de la Unidad de Control, y el resultado de la instrucción activa los
correspondientes indicadores de estado (Signo, Cero, Acarreo,
Sobrepasamiento...) que son utilizados por la Unidad de Control para determinar el
funcionamiento de las siguientes instrucciones. La siguiente figura muestra la
estructura general de una ALU.

El banco de registros proporciona los operandos al elemento de cálculo

(operador), y almacena resultados intermedios y finales. Es frecuente la existencia
de uno de estos registros, denominado acumulador , que suele trabajar como
registro resultado de la operación y tiene un tratamiento especial respecto de las
instrucciones que pueden ejecutarse con él (mayor cantidad y tipos que con los
otros registros).

BANCO
REGISTROS

OPERADOR

Acumulado r

ESTADO

Figura 1. 7. Estructura genérica de la Unidad Aritmético-Lógica.

 El operador suele estar implementado con circuitos combinacionales, y la
Unidad de Control determina su operación en el caso de instrucciones complejas.
Los indicadores de estado (‘flags’) están implementados con biestables,
aunque a nivel de acceso suelen organizarse como parte del registro de estado
comentado anteriormente. Su información permite a la Unidad de Control
determinar la opción de ejecución en instrucciones de bifurcación condicionales.

Conjunto de Instrucciones

La operación de la CPU está determinada por las instrucciones que ejecuta, que
suelen denominarse instrucciones máquina. Puesto que la CPU implementa
distintas funciones, éstas se reflejan en distintos tipos de instrucciones. El
conjunto de las diferentes instrucciones que puede ejecutar una CPU se denomina
conjunto de instrucciones.

Elementos de una instrucción maquina

Cada instrucción debe contener la información que necesita la CPU para su

ejecución. Si nos basamos en el ciclo de instrucción, podemos definir los
elementos de una instrucción:

• Código de operación: especifica el tipo de operación a realizar (suele

representarse de forma simbólica: mnemónico).
• Referencia a operando fuente: la operación puede implicar uno o más
operandos fuente o de entrada.
• Referencia a operando resultado: operando donde se almacenará el
resultado.
• Referencia a la siguiente instrucción: le informa a la CPU dónde buscar
la siguiente instrucción a ejecutar. En el caso más general, la siguiente
instrucción será la inmediatamente posterior en el programa, y no es
 necesaria una referencia explícita, pero sí en caso de saltos, llamadas a
subrutinas, etc.

Los operandos pueden localizarse en:

• Memoria principal o virtual: debe proporcionarse la dirección.

• Registros CPU: si sólo existe uno, la referencia es implícita. Si hay más,
cada registro tendrá un identificador.
• Dispositivo E/S: debe proporcionarse la dirección.

Cada instrucción se representa por una secuencia de bits y está dividida en

campos, cada uno de los cuales contiene uno de los elementos comentados. Esta
estructura se conoce como formato de instrucción. En la siguiente figura se
muestra un ejemplo:

4b 6b 6b

Opcode Operando Operando ≡ 16 bits

Tipos de operación

Aunque el conjunto de instrucciones varía de una CPU a otra, existen algunos

tipos generales de instrucción que son comunes a todas las máquinas. Estos tipos
se pueden clasificar en:

• Transferencia de datos. Deben especificar: 1) localización de los

operandos fuente y destino; 2) longitud de los datos a transferir; 3) Modo
de direccionamiento.
• Operaciones aritméticas. Los tipos usuales son: 1) Suma; 2) Resta; 3)
Multiplicación; 4) División; 5) Valor absoluto; 6) Negación; 7) Incremento;
8) Decremento.
 • Operaciones lógicas. NOT, OR, AND, XOR, desplazamientos lógicos a
derecha e izquierda, desplazamientos aritméticos a derecha e izquierda,
rotaciones a derecha e izquierda.
• Conversión. Modifican el formato de los datos (por ejemplo, conversión
decimal a binaria o entero a coma flotante).
• E/S. Operaciones de lectura/escritura/control de módulos de E/S.
• Control del sistema. Generalmente son operaciones especiales que
pueden ejecutarse sólo cuando el procesador se encuentra en un un
determinado estado o ejecutando un programa privilegiado. Suelen estar
reservadas al SO (por ejemplo, modificación de registros de control o
acceso a bloques de control de proceso en sistemas multiprogramados).
• Transferencia de control. Los tipos usuales son: 1) Salto (condicional e
incondicional); 2) Llamada a subrutina.

Direccionamiento

En la siguiente figura se muestran los modos de direccionamiento de operandos

más comunes:

Para determinar qué modo de direccionamiento se está utilizando en una

instrucción, existen diferentes soluciones. Puede utilizarse diferentes códigos de
operación para cada modo. También pueden reservarse uno o más bits para
determinar el modo de direccionamiento.

* Direccionamiento inmediato. No necesita referencias a memoria para

obtener el operando, pero el valor de la constante está limitado por el
número de bits del campo.
* Direccionamiento directo. Requiere sólo un acceso a memoria sin
cálculos previos de dirección, pero el margen de memoria que puede
direccionar está limitado por el número de bits del campo
correspondiente al operando.
* Direccionamiento indirecto. Permite aumentar el margen de memoria
direccionada respecto al caso anterior, pero requiere dos accesos a
memoria, uno para conseguir la dirección y otro para obtener el valor del
operando.
* Direccionamiento por registro. Similar al directo, pero en este caso, el
campo de dirección contiene referencia a un registro interno en lugar de
memoria. Puesto que el número de registros no suele ser grande, el
 campo de dirección puede ser pequeño, y no se requieren accesos a
memoria.
* Direccionamiento indirecto por registro. Similar al indirecto, pero se evita
el primer acceso a memoria para buscar la dirección, que se toma de un
registro.
 Instrucción

COP R Direc.

Memoria

Operando

Registros

7) Desplazamiento

Figura 1. 9. Modos de direccionamiento.

* Direccionamiento por desplazamiento. Combina el direccionamiento

directo y el indirecto por registro. Necesita dos campos de direcciones,
con al menos uno explícito. El valor contenido en uno de ellos (A) se
utiliza directamente. El otro referencia un registro cuyo contenido se
suma a A para producir la dirección efectiva. Los tipos más comunes
son:
* Direccionamiento relativo. El contenido del registro PC se suma a A para
producir el desplazamiento, que será relativo a la posición actual.
* Direccionamiento basado en registro. Similar al anterior, pero el registro
es otro diferente del PC.
* Indexado. El campo de dirección referencia una dirección de memoria
principal, y el registro referenciado contiene un desplazamiento respecto
a esa dirección.
* Direccionamiento por pila. La pila es una estructura LIFO, que tiene
reservada un bloque de direcciones de memoria. Asociado con la pila
existe un registro puntero que contiene la dirección de la cima de la pila.
Por tanto, referencias a las posiciones de memoria del pila se realizan
mediante el puntero de pila y se comporta como direccionamiento
indirecto por registro.
 1.8. Operación de la Unidad de Control

Microoperaciones
La ejecución de un programa consiste en la ejecución secuencial de
instrucciones. Cada instrucción se ejecuta durante un ciclo de instrucción, que
está constituido por subciclos más cortos (búsqueda operación, búsqueda
indirecta, ejecución, interrupción. Las características de cada subciclo implican
una o más operaciones menores, denominadas microoperaciones.

EJECUCION
PROGRAMA

CICLO CICLO CICLO

INSTRUCCIÓN INSTRUCCIÓN INSTRUCCION

Búsqueda Indirecto Ejecución Interrupción

µ OP µ OP µ OP µ OP µ OP µ OP

Figura 1.10. Elementos constituyentes de la ejecución de un programa.

CICLO DE BUSQUEDA.

El ciclo de búsqueda se produce al comienzo de cada ciclo de instrucción y

produce que una instrucción se cargue en la CPU desde memoria.
Consideraremos la estructura básica de 4 registros internos MAR (Memory Adress
Register), MBR (Memory Buffer Register), PC (Program Counter), IR (Instruction
Register).
MAR MAR Direc. Instr.
MBR Instrucción
MBR
Direc. Instr. PC Direc. Instr.+1
IR

PC
IR

1) Comienzo 3) 2° estado

MAR Direc. Instr. MAR Direc. Instr.

MBR Instrucción
MBR
Direc. Instr. PC Direc. Instr.+1
IR Instrucción

PC
IR
2) 1er estado 4) 3er estado

Figura 1.11. Secuencia de eventos en el ciclo de búsqueda.

Al comienzo del ciclo, la dirección de la siguiente instrucción a ejecutar está en

PC. El primer paso es llevar esta dirección al MAR, puesto que es el único registro
conectado a las líneas de direcciones del bus del sistema. El segundo paso es
pasar este contenido al bus, ejecutar un comando READ mediante el bus de
control y el resultado contenido en el bus de datos es copiado en el MBR.
Necesitamos incrementar el PC. Puesto que estas dos operaciones (leer dato y
sumar 1 al PC) no interfieren entre sí, pueden realizarse simultáneamente. El
tercer paso es mover el contenido de MBR a IR, dejando libre MBR para un
posible ciclo indirecto.
 Por tanto, el ciclo de búsqueda consiste de este modo con tres pasos y 4
microoperaciones. Cada microoperación implica movimiento de datos fuera o
dentro del registro. Mientras no interfieran entre sí, pueden realizarse a la vez.
Simbólicamente puede escribirse el proceso como:

t1: MAR ← (PC)

t2: MBR ← Memory

PC ← (PC)+1

t3: IR ← (MBR)

Estamos suponiendo que el reloj del sistema emite pulsos de igual duración que
definen unidades de tiempo. Cada microoperación deberá realizarse en una
unidad de tiempo. La notación ti representa sucesivas unidades de tiempo.

Control de la CPU

La unidad de control realiza dos tareas básicas:

• Secuenciamiento: Fuerza a la CPU a pasar a través de una serie de

microoperaciones en la secuencia apropiada, basada en el programa
que se está ejecutando.
• Ejecución: Produce la ejecución de cada microoperación.

SEÑALES DE CONTROL.

Para realizar sus funciones, la unidad de control debe disponer de entradas que
le permitan determinar el estado del sistema, y salidas que le permitan controlar
su comportamiento. Esto constituye las especificaciones externas de la unidad de
control. Internamente debe disponer de la lógica requerida para realizar las
funciones de secuenciación y ejecución.
 Registro Instrucciones

Señales Control
Bus Interno CPU

Flags
UNIDAD
CONTROL

Señales Control
Reloj Bus Sistema
Bus Control
Externo
Figura 1.13. Modelo de unidad de control.

Las entradas son:

• Reloj. La unidad de control realiza una o varias microinstrucciones en

una unidad de tiempo. Esto se conoce también como ciclo del
procesador o ciclo de reloj.
• Registro de instrucciones. El código de operación se utiliza para
determinar qué microinstrucciones realizar durante el ciclo de ejecución.
• Flags. Se utilizan para determinar el estado de la CPU e indicar el
resultado de operaciones ALU previas.
• Señales de control del Bus de Control. Este bus proporciona señales a la
unidad de control, como las interrupciones y control del bus.

Las salidas son:

• Señales de control internas a la CPU. Existen dos tipos: las que

producen la transferencia de datos de un registro a otro y las que activan
funciones ALU.
• Señales de control al Bus de Control. Hay dos tipos: señales de control
de memoria y de E/S.

Todas estas señales de control se conectan en última instancia a puertas lógicas

individuales.
Control microprogramado

Los métodos de implementación de la unidad de control pueden clasificarse en

dos categorías:

• Implementación cableada.
• Implementación microprogramada.

En la primera, la unidad de control es básicamente un circuito combinacional, en

el que las entradas lógicas son transformadas en señales lógicas de salida que
constituyen las señales de control. No obstante, en una CPU actual, en el que la
unidad de control puede ser muy compleja, el número de ecuaciones booleanas
que definen el circuito combinacional puede ser muy grande. Además, resulta
difícil testar el circuito , por las múltiples combinaciones a comprobar, así como
posteriores modificaciones.

La implementación microprogramada se basa en la codificación de las

microoperaciones en un lenguaje simbólico, lo que es conocido como lenguaje de
microprogramación. Cada línea describe un conjunto de microoperaciones que
ocurren simultáneamente, y se denomina microinstrucción. Una secuencia de
microinstrucciones se denomina microprograma o 'firmware'. Para cada
microoperación la unidad de control debe general señales de control
determinadas, por lo que pueden codificarse en una palabra de control en la que
hay un bit por cada línea de control.

No obstante, utilizar una palabra de control de este tipo podría dar problemas
cuando la secuencia de microoperaciones no coincide entre instrucciones
diferentes (por ejemplo, a veces se necesita un ciclo indirecto y a veces no).
Podemos aproximarnos a la solución almacenando las palabras de control en una
memoria en la que cada palabra tenga una única dirección. De esta manera, se
puede añadir un campo de dirección a cada palabra de control que indique dónde
se almacena la siguiente palabra de control a ejecutar si se cumplen determinadas
condiciones y algunos bits para especificar la condición.
En este caso el resultado es óptimo desde el punto de vista de la velocidad de los
circuitos, pero tiene poca flexibilidad ya que cualquier cambio en el diseño del set
de instrucciones de la CPU genera la necesidad de re-escribir el diagrama de
estados y, por ende, cambiar todo el circuito lógico que lo implementa. En cambio
la filosofía de “lógica microprogramada” propone que la CU se construya en base
a un autómata más sencillo que “ejecute” el ciclo de instrucción de cada
instrucción de la CPU siguiendo en secuencia un conjunto de “microinstrucciones”
que contienen los valores de las señales apropiados para esa instrucción
particular. Es decir que para cada instrucción a nivel de la CPU existirá un
“microprograma”, consistente en una secuencia lógica de microinstrucciones que
establecerán el orden de los eventos necesarios para lograr la ejecución de la
instrucción en la CPU, incluyendo todas las “bifurcaciones” de la secuencia que se
requieran en base a los distintos tipos de direccionamiento y cualquier otra
variante que admita la instrucción específica. En este caso hay una penalización
en la velocidad de proceso porque el microprograma se almacena en una ROM
interna de la CPU y cada microinstrucción debe ser leída de ella, pero simplifica
enormemente la tarea de modificar el set de instrucciones, ya que simplemente
alcanza con cambiar el contenido de la ROM del microprograma. También las
máquinas microprogramadas permiten fácilmente implementar instrucciones
complejas, tales como la búsqueda de un elemento en un array, ó la copia o la
comparación de arrays, etc.
La tendencia en materia de diseño de CPUs era, hasta la década de 1980, utilizar
lógica microprogramada. La aparición de las arquitecturas RISCs puso en cuestión
esa tendencia, ya que dichas propuestas promovían el uso de lógica cableada, en
particular asociado al concepto de optimizar la velocidad de proceso. De todos
modos es probable que la ventaja que esos diseños obtuvieron en materia de
rendimiento se deba principalmente al uso óptimo de técnicas tales como el
“pipelining” permitido por las características de su set de instrucciones. El punto es
que si se usa un set “reducido” con fines de optimización, también resulta más
sencillo implementar la CPU en “lógica cableada”.

La forma de generar estas señales de control, que serían distintas en cada paso
de programa, puede hacerse mediante un código único para cada posible conjunto
de señales, y añadir entonces al hardware de propósito general un segmento que
acepte estos códigos y genere las señales de control adecuadas. Estos códigos
son básicamente las instrucciones que acepta el hardware, y el conjunto de estas
instrucciones sería el software del sistema.
 El resultado de esto se conoce como microinstrucción horizontal. Tiene un bit
para cada línea de control interna de la CPU y un bit para cada línea del bus de
control externo. Hay un campo de condición que indica la condición para la que se
producirá el salto, y otro campo con la dirección de la siguiente instrucción a
ejecutar en este caso. La microinstrucción se interpretará de la siguiente forma:

1. Para ejecutarla, poner a estado alto todas las líneas de control cuyo bit
representativo esté a '1', y a bajo las que estén a '0'. Las señales resultantes
pueden realizar una o más microoperaciones.

2. Si la condición indicada no se cumple, ejecutar la siguiente microinstrucción.

3. Si la condición se cumple, ejecutar la microinstrucción indicada por el campo de

direcciones.

En microinstrucciones verticales, se utiliza un código para cada acción a realizar,

y un decodificador convierte este código en señales individuales de control. La
ventaja de este tipo es que es más compacto que la microinstrucción horizontal a
expensas de un pequeño incremento de lógica y retraso temporal.

Señales control Condic. Direc.

Señales internas control
bus salto µinstruc.

a) Microinstrucción horizontal

Condic. salto Direc. µ instruc.

Códigos función

b) Microinstrucción vertical

Figura 1.15. Formatos de microinstrucciones.

 La siguiente figura muestra cómo pueden ordenarse estas microinstrucciones en
una 'memoria de control'. Las microinstrucciones de cada rutina se ejecutan
secuencialmente. Cada rutina termina con un salto que indica por dónde se debe
continuar. El ciclo de ejecución representa las distintas rutinas que implementan
las instrucciones máquina a ejecutar dependiendo del código de operación actual.

•
• Rutina Ciclo
• Búsqueda
Salto a Indirecto o Ejecución
•
•
Rutina Ciclo
•
Indirecto
Salto a Ejecución
•
•
•
Rutina Ciclo
Salto a Búsqueda Interrupción
Salto a rutina de Código de Operación

• Comienzo Ciclo Ejecución

•
•
Salto a Búsqueda o Interrupción Rutina Instrucción
• AND
•
•
Salto a Búsqueda o Interrupción
Rutina Instrucción
ADD

• •
• •
• •

•
•
•
Salto a Búsqueda o Interrupción
 Rutina última
Instrucción

Figura 1.16. Organización de la memoria de control.

Esta organización da información sobre el funcionamiento de la unidad de control

para un computador en particular, y proporciona también un método de
implementarla.

Unidad de control microprogramada

Lógica Registro Direcciones Control

Secuenciamiento

Lectura

MEMORIA
CONTROL

Registro Buffer Control

Figura 1.17. Microarquitectura de la unidad de control.

La figura muestra los elementos clave de la implementación microprogramada. El

conjunto de microinstrucciones se almacena en la memoria de control. El registro
de direcciones de control contiene la dirección de la siguiente microinstrucción a
ejecutar. Cuando se lee una microinstrucción de la memoria, se transfiere al
registro buffer de control. La parte izquierda de este registro (que coincide con la
de la microinstrucción horizontal de la figura 1.15.) conecta con las líneas de
control que salen de la unidad de control. Por tanto, leer una microinstrucción de la
memoria de control es equivalente a ejecutarla. El tercer elemento es una unidad
de secuenciamiento que carga el registro de direcciones de control y fuerza un
comando de lectura.

Registro Instrucciones

UNIDAD
CONTROL Decodificador

F lags
ALU Lógica Registro Direcciones Control
Secuenciamiento
Reloj

Lectura

MEMORIA
CONTROL

Registro Buffer Control

Decodificador

Señales Control Señales Control

Internas Bus Sistema

Figura 1.18. Funcionamiento de la unidad de control microprogramada.

Las funciones de la unidad de control son las siguientes:

1. Al ejecutar una instrucción, la unidad lógica de secuenciamiento realiza una
operación de lectura de la memoria de control.

2. La palabra cuya dirección se especifica en el registro de direcciones de control

se copia en el registro buffer de control.

3. El contenido del registro buffer de control genera señales de control e

información sobre la siguiente dirección para la unidad lógica de
secuenciamiento.

4. La unidad lógica de secuenciamiento carga una nueva dirección en el registro

de direcciones de control basándose en la información sobre la siguiente
dirección del buffer de control y los flags de la ALU.

Al finalizar cada microinstrucción, la lógica de secuenciamiento carga una nueva

dirección en el registro de direcciones. Dependiendo de los flags de la ALU y del
buffer de control, existen tres posibilidades de decisión:

- Tomar la siguiente instrucción: sumar 1 al registro de direcciones.

- Saltar a una nueva rutina basándose en una microinstrucción de salto: cargar el

campo de dirección del buffer de control en el registro de direcciones.

- Saltar a una rutina de servicio de instrucción máquina: cargar el registro de

control basándose en el código de operación de IR.

El decodificador superior de la figura traslada el código de operación de IR a la

dirección de la memoria de control. El decodificador inferior no se usa en
microinstrucciones horizontales, sino en verticales, utilizándose para la
decodificación de las señales de control.

La principal ventaja de usar microprogramación para implementar unidades de

control es la simplificación de diseño, lo que conlleva menor coste y menos
posibilidades de error. Una unidad cableada contiene lógica compleja, mientras
que la microprogramada sólo necesita decodificadores y lógica de secuenciación.

La principal desventaja de la microprogramación es su menor velocidad frente a

la cableada para una tecnología dada. No obstante, la microprogramación es la
técnica dominante en los computadores actuales.

1.10. Estructura segmentada

La segmentación de instrucciones aprovecha la circunstancia de que una

instrucción debe pasar por diferentes etapas en su ejecución, por lo que varias
instrucciones pueden ejecutarse a distintos niveles de forma simultánea. Este
proceso se denomina 'pipelining' ya que, como ocurre en una 'pipeline', se aceptan
nuevas entradas por un lado antes de que las anteriores produzcan resultados por
el otro lado.

Como aproximación, supongamos la instrucción subdividida en dos etapas:

búsqueda y ejecución. Habrá momentos durante la ejecución en que no se
accederá a la memoria principal. Este tiempo puede utilizarse para buscar la
siguiente instrucción a realizar.

Espera Nueva direcc. Espera

Instrucción Instrucción Resultado

Búsqueda Ejecución

Eliminar

Figura 1.19. Pipeline de instrucciones de dos etapas.

 En este caso, la pipeline tiene dos etapas independientes. La primera busca una
instrucción y la almacena. Cuando la segunda etapa está libre, la primera pasa la
instrucción. Mientras la segunda está ejecutándola, la primera aprovecha los ciclos
en que no se utiliza la memoria para buscar y almacenar la siguiente. Esto se
conoce como 'pre-búsqueda de instrucción' o 'búsqueda solapada'. En principio, si
los tiempos de búsqueda y ejecución fueran iguales, este método proporcionaría
el doble de velocidad de la máquina. En la práctica, no suele ser así por dos
razones:

1. El tiempo de ejecución es generalmente mayor que el de búsqueda.

2. Instrucciones de salto condicional no permiten conocer la siguiente instrucción

a ejecutar hasta la ejecución de la previa, por lo que en principio se deberá
esperar en el proceso de búsqueda.

Puede reducirse este segundo tiempo buscando la siguiente operación después

de un salto condicional. Si no se cumple el salto, no habrá pérdida de tiempo. Si
se cumple, la instrucción siguiente se descarta.

Para incrementar la velocidad, la pipeline puede descomponerse en más etapas.

Consideremos la siguiente descomposición de una instrucción:

1. Búsqueda de instrucción (FI): lee la siguiente instrucción a ejecutar y la copia en

el buffer.

2. Decodificar instrucción (DI): determina el código de operación y los

especificadores de operandos.

3. Cálculo de operandos (CO): calcula la dirección efectiva de cada operando

fuente.

4. Búsqueda de operandos (FO): busca cada operando en memoria. Los

operandos en registros no necesitan ser buscados.

5. Ejecución de la instrucción (EI): realiza la operación indicada y almacena el

resultado, si es necesario, en la posición especificada.
 Con esta descomposición, las diversas etapas tienen aproximadamente la misma
duración. Suponiendo igual duración, y no permitiendo que más de una etapa que
acceda a memoria esté activa a la vez, la pipeline de 5 etapas puede reducir el
tiempo de ejecución para tres instrucciones de 15 unidades a 9. FI siempre implica
acceso a memoria, pero FO y EI no siempre lo necesitan. No obstante, en este
caso se ha supuesto que lo hacen.

1 2 3 4 5 6 7 8 9 tiempo

FI DI CO FO EI
Instrucc.
1 FI DI CO FO EI

FI DI CO FO EI
Instrucc.
2

Instrucc. 3

Figura 1.20. Diagrama de tiempos para la operación pipeline.

No obstante, algunos factores siguen limitando las ventajas de la pipeline. Si las

cinco etapas no son iguales, habrá alguna espera implicada en las diversas
etapas. También los saltos condicionales y las solicitudes de interrupción reducen
la efectividad.

Otro problema se refiere a que la etapa CO puede depender del contenido de un

registro que es modificado por la instrucción anterior todavía en la pipeline.
Pueden darse también otros conflictos referidos a registros o memoria. El sistema
debe disponer de lógica adecuada para resolver estos conflictos.
 Además, para mejorar la eficiencia de la pipeline, se deberá disponer de lógica
adicional. Si, por ejemplo, una etapa EI no necesita acceder a memoria, otra etapa
de otra instrucción que sí lo necesite podrá ejecutarse en paralelo.

A la vista de esta discusión, puede parecer que un mayor nº de etapas en una

pipeline implica una mayor velocidad de proceso. No obstante, existen dos
factores en contra:

- Cada etapa de la pipeline tiene asociado un tiempo utilizado en movimientos

entre buffers y otras funciones de preparación internas que puede ser
significativo cuando el nº de etapas se incrementa, reduciéndose por tanto el
tiempo de cada una de ellas.

- La cantidad de lógica necesria para controlas las dependencias de memoria y

registros y ara optimizar el uso de la pipeline crece muy rápidamente con el nº
de etapas, puediéndose dar el caso de que la lógica de control de las etapas es
más compleja que las
etapas a controlar.

Uno de los principales problemas en el diseño de pipelines es asegurar un flujo

estable de instrucciones. El principal impedimento es el salto condicional. Para
solucionar esto, hay diversas aproximaciones:

1. Canales múltiples. Una pipeline simple es penalizada por una instrucción de

salto puesto que debe escoger una de dos instrucciones a buscar, y puede
escoger erróneamente. Si se dispone de varios canales, cada uno puede
cargarse con una opción. Un problema de esta aproximación es la posibilidad
de que una nueva instrucción de salto entre en la pipeline (en ambos canales)
antes de que la lógica resuelva el salto original. Se necesitarían, pues, múltiples
canales para evitar esto, con lo que el hardware se complica.

2. Prebúsqueda de la opción del salto. Cuando se reconoce un salto, se busca

también la siguiente instrucción a él, a la vez que la posible. Esta última se
mantiene hasta la ejecución de la operación salto. Si se da, se continúa con esa
variación.
3. Predicción del salto. Se utilizan diversas técnicas para predecir si el salto se
dará o no. Se basan en análisis del histórico de instrucciones anteriores, o en
alguna medida dinámica de la frecuencia reciente de saltos.

Registro de control y estado

Para discutir y comprender el funcionamiento del procesador, podemos considerar

los requisitos que tiene que cumplir:
1. Buscar instrucciones desde la memoria o desde un dispositivo de entrada y
salida
2. Decodificar instrucciones para determinar que acción es necesaria
3. Buscar los datos que la ejecución de la instrucción puede requerir
4. Procesar los datos que la ejecución puede necesitar a través de una operación
lógica o aritmética
5. Almacenar los resultados donde corresponda Para hacer estas cosas es claro
que el procesador debe almacenar algunos datos temporalmente.
Debe recordar la posición de la ´ultima instrucción de forma de poder determinar
de donde tomar la siguiente. Necesita almacenar instrucciones y datos
temporalmente mientras una instrucción está ejecutándose. En otras palabras, el
procesador
necesita una pequeña memoria interna.
Dentro del procesador hay un conjunto de registros clasificados en dos tipos:
Registros visibles al programador: permiten al programador de lenguaje máquina o
de ensamblador minimizar las referencias a memoria principal por medio de la
optimización de uso de registros Registros de control y estado: Son utilizados por
la unidad de control para controlar el funcionamiento del procesador y por
programas privilegiados del sistema operativo para controlar la ejecución de
programas.

Registros de control y estado

Hay diversos registros del procesador que se emplean para controlar su
funcionamiento. La mayoría de ellos, en la mayor parte de las máquinas no son
visibles por el usuario, pero alguno de ellos puede ser visible por ciertas
instrucciones máquina ejecutadas en un modo privilegiado o de sistema operativo.
Naturalmente, diferentes máquinas tendrían distinta organización de registros y
usaran distinta terminología. Son esenciales cuatro registros para la ejecución de
una instrucción:
 Contador de programa (Program Counter- PC):
 Contiene la dirección de la instrucci´on a buscar
 Registro de instrucción (Instruction Register- IR): Contiene la instrucción
buscada mas recientemente
 Registro de dirección de memoria (Memory Address Register- MAR)
Contiene la dirección de una posición de memoria
  Registro amortiguador de memoria (Memory Buffer Register - MBR)
Contiene el dato a escribir en una posición de memoria o el dato contenido
en una posición de memoria leído mas recientemente

No todos los procesadores tienen registros internos designados como MAR o MBR
pero se necesita algún mecanismo de almacenamiento intermedio equivalente
mediante el cual se de salida a los bits que van a ser transferidos por el bus de
sistema se almacenen los bits leídos por el bus de datos.

Típicamente, el procesador actualiza el PC luego de cada búsqueda de instrucción

(ver figura), de manera que siempre apunte a la siguiente instrucción a ejecutar.
Una instrucción de bifurcación o salto también modificar´ a el valor del registro PC.
La instrucción buscada se carga en IR, donde son analizados los códigos de
operación y los campos de operando. Se intercambian datos con la memoria por
medio del MAR y el MBR. El MAR se conecta con el bus de direcciones y el MBR
con el bus de datos. Los registros visibles por el usuario repetidamente cambian
datos con MBR.

Los registros mencionados se usan para la transferencia de datos entre el

procesador y la memoria principal. Dentro del procesador, los datos tienen que
ofrecérsele a la ALU para su procesamiento. La ALU puede tener acceso directo al
MBR y a los registros visibles por el programador, pero alternativamente puede
haber registros intermedios en torno a la ALU, que le sirven como entrada y salida
e intercambian datos con el MBR y los registros visibles al programador.

Muchos diseños de procesadores incluyen un registro o un conjunto de registros,

conocidos a menudo como palabra del estado de programa o program status word
(PSW), que contiene información de estado. Típicamente contiene códigos de
condición, incluyendo a menudo los siguientes bits de estado:

 El signo del resultado de la ´ultima operación

 Indicador de resultado cero o nulo
 Indicador de acarreo en la ´ultima operación (suma o resta)
 Indicador de igualdad entre operadores
  Indicador de desbordamiento aritmético
 Habilitación de interrupciones
 Indicador de modo supervisor (para permitir ciertas instrucciones
privilegiadas)

En algunos diseños es posible encontrar otros registros relativos a estado y

control. Puede existir un puntero a bloque de memoria que contenga información
de estado adicional (por ejemplo, bloques de control de procesos). En las
máquinas que utilizan interrupciones vectorizadas puede existir un registro de
vector de interrupciones. Si se utiliza una pila para llevar a cabo ciertas funciones,
se necesita un puntero a pila del sistema. En un sistema de memoria virtual se
utiliza un puntero a una tabla de paginas. por ´ultimo, pueden utilizarse registros
para el control de operaciones de E/S.

El ciclo de instrucción
Un ciclo de instrucción incluye los siguientes subciclos:

 Captación: llevar la siguiente instrucción de la memoria al procesador.

 Ejecución: interpretar el código de operación y llevar a cabo la operación
indicada.
 Interrupción: si las interrupciones están habilitadas y ha ocurrido una
interrupción, guardar el estado del proceso actual y atender la interrupción.

El Ciclo Indirecto
La ejecución de una instrucción puede involucrar a uno o más operandos en
memoria, cada uno de los cuales requiere un acceso a memoria. Además, si se
usa direccionamiento indirecto serán necesarios accesos a memoria adicionales.
Podemos considerar la captación de direcciones indirectas como un subciclo de
instrucción más. El resultado se muestra en la Figura La principal línea de
actividad consiste en alternar las actividades de captación y ejecución de
instrucciones. Después de que una instrucción sea captada, es examinada para
determinar si incluye algún direccionamiento indirecto. Si es así, los operandos
requeridos se captan usando direccionamiento indirecto. Tras la ejecución se
puede procesar una interrupción antes de la captación de la siguiente instrucción.

Ilustración 19 ciclo de instrucciones

Esta nueva figura ilustra más correctamente la naturaleza del ciclo de instrucción.
Una vez que una instrucción es captada, deben identificarse sus campos de
operandos. Se capta entonces de la memoria cada operando de entrada, y este
proceso puede requerir direccionamiento indirecto. Los operandos ubicados en
registros no necesitan ser captados. Una vez que se ejecuta la operación, puede
ser necesario un proceso similar para almacenar el resultado en la memoria
principal.

Ciclo Fetch-Decode-Execute

Procedimiento bien establecido Fases(o sub ciclos): búsqueda y ejecución (cada

fase tiene etapas o actividades)

FASE FETCH
 Cargar la siguiente instrucción
 Incrementar el secuenciador
  Interpretar la Instrucción
FASE EXECUTE
 Cargar los operandos
 Ejecutar la operación
 Guardar el resultado
 Verificar si hay solicitudes de interrupción
Elementos Para Construir El CPU.

Un conjunto de instrucciones o repertorio de instrucciones, juego de instrucciones

o ISA (del inglés Instruction Set Architecture, Arquitectura del Conjunto de
Instrucciones) es una especificación que detalla las instrucciones que una CPU de
un ordenador puede entender y ejecutar, o el conjunto de todos los comandos
implementados por un diseño particular de una CPU. El término describe los
aspectos del procesador generalmente visibles a un programador, incluyendo los
tipos de datos nativos, las instrucciones, los registros, la arquitectura de memoria y
las interrupciones, entre otros aspectos.

Existen principalmente de 3 tipos: CISC (Complex Instruction Set Computer), RISC

(Reduced Instruction Set Computer) y SISC (Simple Instruction Set Computing).

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para

distinguir este conjunto de características de la microarquitectura, que son los
elementos y técnicas que se emplean para implementar el conjunto de
instrucciones. Entre estos elementos se encuentran las microinstrucciones y los
sistemas de caché.

Procesadores con diferentes diseños internos pueden compartir un conjunto de

instrucciones; por ejemplo, el Intel Pentium y AMD Athlon implementan versiones
casi idénticas del conjunto de instrucciones x86, aunque tienen diseños diferentes.

Características que debe tener un conjunto de instrucciones:

Las características que se pretende que tenga un conjunto de instrucciones son
cuatro, principalmente:

 Completo: Que se pueda realizar en un tiempo finito cualquier tarea

ejecutable con un ordenador (computable o decidible).
 Eficiente: Que permita alta velocidad de cálculo sin exigir una elevada
complejidad en su UC y ALU y sin consumir excesivos recursos (memoria),
es decir, debe cumplir su tarea en un tiempo razonable minimizando el uso
de los recursos.
 Autocontenidas: Esto es, que contengan en sí mismas toda la información
necesaria para ejecutarse.
 Independientes: Que no dependan de la ejecución de alguna otra
instrucción.
Se puede comprobar que para que un conjunto de instrucciones sea completo solo
se necesitan cuatro instrucciones:
 Escritura
 Mover a la izquierda una posición y leer
 Mover a la derecha una posición y leer
 Parar

En esta idea se basan las arquitecturas RISC, no obstante, con este conjunto no
se puede conseguir la eficiencia del repertorio de instrucciones por lo que en la
práctica el conjunto suele ser más amplio en aras de conseguir un mejor
rendimiento, tanto en uso de recursos como en consumo de tiempo.

Modos de Direccionamiento.

Contar con diferentes formatos de instrucciones, implica contar con diferentes

formas de obtener los operandos de las instrucciones. Por lo general a estas
múltiples formas se les conoce como modos de direccionamiento. Los modos de
direccionamiento en MIPS son:
Direccionamiento por registro, donde los operandos son registros. Los datos a
operar están contenidos en 2 registros de 32 bits y el resultado será colocado en
otro registro, del mismo tamaño.
Ejemplos de instrucciones que usan este modo de direccionamiento: add, sub, slt,
etc.

Direccionamiento base o desplazamiento, donde uno de los operandos está en

una localidad de memoria cuya dirección es la suma de un registro y una
constante que forma parte de la misma instrucción.
Ejemplos de instrucciones que usan este modo de direccionamiento: lw, sw, etc.

Direccionamiento inmediato, donde uno de los operandos es una constante que

está en la misma instrucción.
Ejemplos de instrucciones que usan este modo de direccionamiento: addi, slti, etc

Direccionamiento relativo al PC, donde se forma una dirección sumando una

constante, que está en la instrucción, con el registro PC (Program Counter). El
resultado de la suma corresponde a la dirección destino si un brinco condicional se
va a realizar.
Ejemplos de instrucciones que usan este modo de direccionamiento: beq y bne.

Direccionamiento pseudo directo, donde la dirección destino de un salto

corresponde a la concatenación de 26 bits que están en la misma instrucción con
los bits más significativos del PC.
Ejemplos de instrucciones que usan este modo de direccionamiento: j y jal.

Es importante mencionar que estamos estudiando una arquitectura con

direcciones de 32 bits, sin embargo, MIPS, como muchas otras arquitecturas, tiene
una extensión que maneja direcciones de 64 bits. Esto como una respuesta a la
necesidad de manejar programas cada vez más grandes.

EL CICLO DE INSTRUCCIÓN
El ciclo de instrucción.
 Es el período que tarda la unidad central de proceso (CPU) en ejecutar una
instrucción de lenguaje máquina.
  Comprende una secuencia de acciones determinada que debe llevar a cabo
la CPU.
 para ejecutar cada instrucción en un programa.
 Cada instrucción del juego de instruccionesde una CPU.
 Puede requerir diferente número de ciclos de instrucción para su ejecución.

Un ciclo de instrucción incluye los siguientes subciclos:

 Captación: Llevar la siguiente instrucción de la memoria al procesador.

 Ejecución: Interpretar el código de operación y llevar a cabo la operación
indicada.
 Interrupción: Si las interrupciones están habilitadas y ha ocurrido una
interrupción, guardar el estado del proceso actual y atender la interrupción.

El Ciclo Indirecto
La ejecución de una instrucción puede involucrar a uno o más operandos en
memoria, cada uno de los cuales requiere un acceso a memoria. Además, si se
usa direccionamiento indirecto serán necesarios accesos a memoria adicionales.
Podemos considerar la captación de direcciones indirectas como un subciclo de
instrucción más.La principal línea de actividad consiste en alternar las actividades
de captación y ejecución de instrucciones. Después de que una instrucción sea
captada, es examinada para determinar si incluye algún direccionamiento
indirecto. Si es así, los operandos requeridos se captan usando direccionamiento
indirecto. Tras la ejecución se puede procesar una interrupción antes de la
captación de la siguiente instrucción.
Los pasos a seguir para el procesamiento de las instrucciones son los siguientes:

1. cada instrucción es leída ( una a la vez), desde la memoria, por el procesador.

2. cada instrucción es ejecutada por el procesador. La repetición de la lectura y
ejecución ( pasos 1 y 2 respectivamente), conforman la “ejecución de un
programa”. Dicha ejecución puede detenerse si: la máquina se apaga, ocurre un
error que no puede ser recuperado, o si, se encuentra una instrucción en el
programa que detenga la computadora.

Lectura y ejecución de instrucciones:

El procesador lee una instrucción de la memoria, al comienzo de cada Ciclo de

instrucción. Se cuenta con un contador de programas ( PC program counter ), que
lleva la cuenta de cual es la próxima instrucción a leer. Luego de leer cada
instrucción el procesador incrementara el PC, de manera tal que la siguiente
instrucción a leer será; la que se encuentra en la dirección inmediatamente
superior de la memoria. La instrucción leída es cargada en el registro de
instrucción ( IR instuction register ), que es un registro del procesador. El
procesador interpreta la instrucción, la cual está en forma de código binario, que
especifica la acción que el procesador llevará a cabo, y realizará la acción
requerida.

Ciclo de instrucción:
Un ciclo de instrucción (tambien llamado ciclo de traer y ejecutar) es el período de
tiempo durante el cual un ordenador lee y procesa una instrucción de lenguaje
máquina de su memoria o la secuencia de acciones que la unidad central (CPU)
funciona para ejecutar cada instrucción de código de máquina en un programa.
El nombre el ciclo traer-y-ejecutar comúnmente es usado.La instrucción debe ser
traída de la memoria principal, y luego ejecutado por la CPU.Esto es
fundamentalmente como un ordenador funciona, con su lectura de CPU y
ejecución de una serie de instrucciones escritas en su lenguaje máquina.De esto
surgen todas las funciones de un ordenador familiar a partir del final del usuario.
La CPU de cada ordenador puede tener ciclos diferentes basados en juegos de
instrucción diferentes.
Para traer la instruccion desde la memoria principal la CPU presenta el valor de la
PC sobre el bus de dirección.La CPU entonces trae la instrucción de la memoria
principal vía el bus de datos en el Registro de Datos de Memoria (MDR).El valor
del MDR entonces es colocado en el Registro de Instrucción Actual un circuito que
sostiene la instrucción de modo que pueda ser descifrado y ejecutado.

Memory Data Register (MDR)

Al decodificar la instrucción el decodificador de instrucción interpreta y pone en
práctica la instrucción.
Registros que son críticos al ejecutar la traída:
El registro de instrucción (IR) - mantiene la instrucción actual. La PC - sostiene la
dirección en la memoria de la siguiente instrucción a ser ejecutada.
Al traer archivos desde la memoria principal se lee la dirección eficaz de la
memoria principal si la instrucción tiene una dirección indirecta. Traer requiere
datos de la memoria principal para ser procesados y colocados en registros.

Ciclo de instrucción:
Del registro de instrucción, los datos que forman la instrucción son descifrados por
la unidad de control.
Pasa la información descifrada como una secuencia de señales de control a las
unidades de función relevantes de la CPU para realizar las acciones requeridas
por la instrucción como la lectura de valores de registros.
Los valores de registro pasan a la Unidad Aritmética lógica (ALU) para añadirlos
juntos y escribiendo el resultado de vuelta al registro. Una señal de condición es
enviada de regreso a la unidad de control por ALU si está implicado.
El resultado generado por la operación es almacenado en la memoria principal, o
enviado a un dispositivo de salida. Basado en la regeneración de condición del
ALU, la PC es incrementada para dirigir la siguiente instrucción o para actualizar a
diferentes direcciones de donde será traída la siguiente instrucción. El ciclo
entonces es repetido.

Ciclo de ejecución:
Proceso de memoria. La informacion es tranferida entre el CPU y el modulo I/O.
Proceso de datos usa operaciones matemáticas así como operaciones lógicas en
la referencia a datos.Alteraciones centrales
Una secuencia de operaciones, por ejemplo un salto la operación.
El último paso es una operación combinada de todos los otros pasos.

Hay siete tipos diferentes de ciclos de maquina en el 8085

Búsqueda de cop. Op
Lectura de MEMORIA
Escritura a MEMORIA
Lectura de E/S
Escritura a E/S
Respuesta a interrupción
Bus inactivo
La función básica que realiza un computador es la ejecución de un programa. Un
programa consiste en un conjunto de instrucciones y datos almacenados en la
unidad de memoria. La CPU es la encargada de ejecutar las instrucciones
especificadas en el programa.

La secuencia de operaciones realizada en la ejecución de una instrucción

constituye lo que se denomina ciclo de instrucción.

La culminación de cada una de estas fases necesita de una a seis ciclos de reloj.

EXECUTION
Durante una operación normal, el procesador busca secuencialmente y ejecuta
una instrucción tras otra, hasta que se procesa una instrucción (HALT) de paro. La
búsqueda y ejecución de una instrucción constituyes el ciclo de instrucción, que
representa a su vez una o más operaciones de acceso a memoria o a dispositivos
de E/S. cada acceso a memoria requiere un ciclo de máquina.
 EJEMPLOS DE CILOS EN MAQUINAS

Es la acción de leer una instrucción en la CPU y prepararla para su ejecución se

denomina ciclo de captación.

Para completar una instrucción la CPU de codifica el opcode, que genera las
señales de control que se necesitan para introducir los operadnos requeridos y
controla la ejecución de la instrucción.

Durante el ciclo de captación, el opcode de la siguiente instrucción es cargado en

el IR(Registro de Instrucción) y la porción de dirección es cargada en el
MAR(Registro de Dirección de Memoria): esta instrucción puede ser tomada del
IBR(Registro de Buffer de Instrucción), o puede ser obtenido de la memoria
cargando una palabra en el MBR(Registro de Buffer de Memoria), y después al
IBR, IR, y MAR

CONJUNTO DE INSTRUCCIONES
Un conjunto de instrucciones o repertorio de instrucciones, juego de instrucciones
o ISA (del inglés Instruction Set Architecture, Arquitectura del Conjunto de
Instrucciones) es una especificación que detalla las instrucciones que una CPU de
un ordenador puede entender y ejecutar, o el conjunto de todos los comandos
implementados por un diseño particular de una CPU. El término describe los
aspectos del procesador generalmente visibles a un programador, incluyendo los
tipos de datos nativos, las instrucciones, los registros, la arquitectura de memoria y
las interrupciones, entre otros aspectos.

Existe principalmente de 3 tipos: CISC (Complex Instruction Set Computer), RISC

(Reduced Instruction Set Computer) y SISC (Specific Instruction Set Computer).

Los procesadores de los microcontroladores PIC son de tipo RISC.

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para
distinguir este conjunto de características de la microarquitectura, que son los
elementos y técnicas que se emplean para implementar el conjunto de
instrucciones. Entre estos elementos se encuentras las microinstrucciones y los
sistemas de caché.

Características generales de los conjuntos de

instrucciones

Ante el diseño de un nuevo ordenador de propósito general hay que plantearse la

siguiente cuestión: ¿Qué tipos de instrucciones deben ser incluidos en su
conjuntos de instrucciones? Antes de responder a esta pregunta, analizaremos las
características que deben tener los juegos de instrucciones de las máquinas. Los
conjuntos de instrucciones de las máquinas deben tender a poseer una serie de
propiedades, bastante ideales e imprecisas, que pueden resumirse en las
siguientes:
 El conjunto de instrucciones de un computador debe ser completo en el
sentido de que se pueda construir un programa para evaluar una función
computable usando una cantidad de memoria razonable y empleando un
tiempo moderado, es decir, el número de instrucciones de ese programa no
debe ser demasiado elevado.
 Los juegos de instrucciones también tienen que ser eficientes, esto significa
que las funciones más necesarias deben poder realizarse usando pocas
instrucciones.
  El conjunto de instrucciones de una máquina debe ser regular, es decir
debe ser simétrico (por ejemplo, si existe una instrucción de
desplazamiento a la izquierda, debe haber otra de desplazamiento a la
derecha, etc.) y ortogonal, es decir, deben poder combinarse, en la medida
de lo posible, todos las operaciones con todos los tipos de datos y modos
de direccionamiento.
 En muchas ocasiones, también se le debe exigir a un computador que su
juego de instrucciones sea compatible con modelos anteriores.

Tipos de instrucciones

Una máquina puede llegar a funcionar con un juego de instrucciones muy limitado
(recuérdese, por ejemplo, la máquina de Turing que sólo tiene 4 instrucciones,
incluso se han diseñado máquinas teóricas con menos instrucciones), esto
simplificaría mucho los circuitos de la máquina. Sin embargo, un conjunto de
instrucciones demasiado simplificado origina, como consecuencia, unos
programas demasiado complejos e ineficientes. Es necesario encontrar un
compromiso entre la simplicidad del hardware y del software. Un mínimo para
llegar a ese compromiso se consigue con los tipos de instrucciones siguientes:
 Instrucciones de transferencia de datos.
 Instrucciones aritméticas.
 Instrucciones lógicas.
 Instrucciones de control del flujo del programa (bifurcaciones, bucles,
procedimientos, etc.)
 Instrucciones de entrada y salida.

En los apartados siguientes iremos viendo con detalle algunos de estos

tipos de instrucciones. Si bien es cierto que el conjunto de instrucciones
debe de cumplir unos mínimos para conseguir una mínima eficiencia en los
programas, también se verá que ésta no se aumenta indefinidamente al
incrementar el número de instrucciones de la máquina.
 Instrucciones de transferencia de datos

La operación de copiar datos de un lugar a otro es la operación más simple y a la

vez importante. Las palabras mover o cargar que aparecen en los juegos de
instrucciones de muchos ordenadores pueden dar lugar a confusión porque no se
trata de mover o cargar sino de copiar (generalmente, en Informática, la palabra
mover tiene el significado de copiar borrando el original). Las instrucciones de
transferencia de datos necesitan que se especifiquen el original (fuente u origen) y
el lugar donde se desea la copia (destino). Esta especificación variará según sean
estos lugares que pueden estar en tres sitios: registros del procesador, memoria o
cima de pila. Si el acceso es a una dirección de memoria habrá que especificarla
de forma explícita, si se trata de la cima de pila normalmente la especificación será
implícita, lo mismo ocurrirá si se trata del acumulador. Existen algunas variantes
de instrucciones de transferencia de datos que difieren de la idea anterior de
copiar informaciones de un lugar a otro. Por ejemplo, la instrucción POP saca un
dato de la cima de pila modificando el valor del apuntador de pila, lo que significa
que, si bien no
destruye físicamente el dato fuente, anula su validez. Por otro lado, la mayoría de
las máquinas también disponen de instrucciones de intercambio (SWAP).
También, en muchas máquinas, existen instrucciones de transferencia de
información entre bloques o cadenas en la que deben especificarse las
direcciones de fuente y destino y la longitud del bloque o cadena. En general, el
dato a transferir podríamos definirlo como una terna con las siguientes
componentes:

 Dirección
 Tipo
 Valor

Normalmente la componente del dato que se transfiere es el valor pero existen

instrucciones especiales para transferir las demás componentes, en especial la
dirección. La extracción de la dirección de un dato se hace necesaria para facilitar
la relocalización de los programas. Para aplicar muchos modos de
direccionamiento (indexados, autoindexados, etc.) es necesaria la transferencia de
una dirección a un registro. En muchos ordenadores esta dirección no se conoce a
la hora de compilar el programa (precisamente porque el programa es
relocalizable), por tanto, son necesarias instrucciones que calculen la dirección de
un dato para transferirla a un registro, actualmente la mayoría de las máquinas
poseen este tipo de instrucción bajo el nombre de move address. Dependiendo del
nivel de ortogonalidad de la máquina, podemos tener más o menos instrucciones
de transferencia. Por ejemplo el IBM-370 tiene más de 20 instrucciones de
transferencia por su falta de ortogonalidad; sin embargo, el PDP-11 sólo tiene 2
para datos enteros (MOV y MOVB) y 4 más para datos en punto flotante, ya que
en las instrucciones de punto flotante se prescindió bastante de la ortogonalidad
por falta de espacio para la codificación. El MC68000 está en un punto intermedio,
tiene varios formatos distintos dependiendo del direccionamiento utilizado. El Z-80
en cuanto a instrucciones de transferencia entre registros es bastante ortogonal,
pero esa ortogonalidad se pierde cuando se trata de otros direccionamientos.

Instrucciones aritméticas y lógicas

la utilidad de este tipo de operaciones es evidente y no la comentaremos. En

cuanto a las operaciones lógicas (AND, OR, NOT y XOR) tienen un uso muy
variado: desde operaciones con bits individuales (TEST, SET, RESET y CHANGE)
hasta el empaquetamiento y desempaquetamiento de caracteres. También
pueden considerarse dentro de este grupo los desplazamientos y rotaciones cuya
utilidad queda fuera de toda duda. En primer lugar, veremos cómo se emplean las
instrucciones lógicas para realizar operaciones de bit individual. La utilidad de
estas operaciones es muy variada, probablemente su aplicación más importante
sea empaquetar en un byte varias variables booleanas, ocupando cada una de
ellas un solo bit. Para analizar un determinado bit se debe tener en cuenta las
siguientes propiedades de la operación AND (. o ∧):

Ilustración 20 analisis de un bit

Ilustración 21Puesta 0 de un bit

Para aplicarlas, se realiza una operación AND del dato que se quiere analizar con
una máscara que tenga un 1 en el lugar cuyo bit se quiere probar con el resto de
la máscara a 0. El resultado de la operación será 0 si el bit en cuestión es 0, o
distinto de 0 si el bit que se quiere probar es 1; por tanto, el resultado de la prueba
quedará en el flag Z en forma complementada como se muestra en la figura 4.1.
Muchas máquinas tienen esta operación bajo el nombre de BIT TEST. Para poner
a 0 un bit de un dato, se aprovechan las mismas propiedades del operador AND.
Para aplicarlas, se construye una máscara que tenga a 1 todos los bits excepto el
correspondiente al lugar que se quiere borrar que se pone a 0 y se hace un AND
de esta máscara con el dato que se quiere tratar; como resultado de la operación
tendremos el mismo dato pero con el bit puesto a cero. El proceso se muestra en
la figura 4.2. Esta operación puede realizarse con varios bits a la vez, basta poner
en la máscara 0 todos los bits que se quieran borrar. Muchos ordenadores poseen
esta instrucción con el nombre de BIT CLEAR o BIT RESET. Para poner un bit a 1
en un dato, aplicaremos las propiedades de la operación OR (+ o ∨):
0 ∨ x = x, ∀x 1 ∨ x = 1, ∀x
En este caso, se construye una máscara con un 1 en el lugar del bit que se quiera
poner a
1 y 0 en el resto. Se realiza la operación OR entre esta máscara y el dato y el
resultado será el
mismo dato pero con el bit en cuestión puesto a 1 (figura 4.3). Esta operación
puede realizarse
con varios bits a la vez poniendo a 1 en la máscara todos los bits que se quieran
poner a 1.
Muchos ordenadores tienen esta operación con el nombre de BIT SET.
Para complementar bits en un dato aplicaremos las propiedades de la operación
OR exclusivo o XOR (⊕):

Ilustración 22Puesta 1 de un bit

Ilustración 23Complemento de un bit

0 ⊕ x = x, ∀x 1 ⊕ x = x, ∀x

Para ello se construye una máscara con un 1 en el bit que se quiere complementar
y 0 en el resto de las posiciones. Después de hacer un XOR de la máscara con el
dato se tendrá el mismo dato con el bit complementado (figura 4.4). Esta
operación también se puede hacer con varios bits a la vez poniendo a 1 en la
máscara todos los bits que se quieran complementar. Algunas máquinas tienen
esta operación en su juego de instrucciones como BIT CHANGE.
Otra utilidad de la operación XOR es la determinación de los bits diferentes que
hay entre dos datos, para ello se hace un XOR entre ellos y los lugares que
queden a 1 son los bits diferentes entre los dos datos. Esto es debido a que la
tabla de verdad de XOR es la complementaria a la de la igualdad entre dos bits.
Esta propiedad también es útil para determinar cuándo dos datos son iguales en
todos sus bits: en este caso el OR exclusivo entre ellos nos dará 0 y, en caso
contrario, tendremos un número no nulo; este resultado puede luego ser analizado
mediante el flag Z. De aquí también se puede deducir que haciendo la operación
XOR de un operando consigo mismo el resultado da 0. Esta es una forma muy
rápida de poner a 0 los registros en algunos procesadores. Otra propiedad muy útil
del operador XOR es que si se opera dos veces con el mismo operando se
regenera el dato inicial, es decir, (x ⊕ y) ⊕ y = x, ∀x, y
Esta propiedad es útil en aplicaciones gráficas para mover cursores por pantalla.
Una utilidad directa de las operaciones lógicas es el manejo de conjuntos tal y
como se hace en el lenguaje Pascal. Supongamos el conjunto universal, U = {x0,
x1, x2,...,xn−1} Si A es un conjunto, contenido en este conjunto universal, puede
representarse internamente en la memoria de la máquina mediante la cadena de n
bits an−1an−2 ...a1a0
en que el valor del bit i indicará la pertenencia del elemento xi al conjunto A. En
otras palabras, ai = ⎧ ⎪⎨ ⎪⎩ 1 si xi ∈ A 0 si xi ∈/ A
A partir de lo anterior resulta bastante evidente que la unión e intersección de dos
conjuntos vendrá representada respectivamente por las operaciones OR y AND
sobre sus cadenas de bits. De la misma forma el complemento de un conjunto se
representa mediante la negación de la cadena de bits que le corresponde.
Mediante esta técnica puede determinarse:
La igualdad de dos conjuntos, analizando si sus cadenas de bits son iguales. La
pertenencia de un elemento x a un conjunto A, realizando un test del bit
correspondiente a x en la cadena de bits que representa al conjunto A. Si un
conjunto es vacío, analizando si su cadena de bits es nula. La inclusión de un
conjunto A en otro B; esto podría hacerse analizando en un bucle si todos los bits
activados en la cadena correspondiente a A también lo están en la cadena que
corresponde a B. Esto sería algo complicado en cuanto a la programación y
llevaría un tiempo de cálculo desproporcionado. Sin embargo, se puede realizar la
misma comprobación de una forma más simple aplicando alguna de las tres
propiedades siguientes: A ⊂ B ⇔ A ∪ B = B, A ⊂ B ⇔ A ∩ B = AoA ⊂ B ⇔ A ∩ B
=∅
Evidentemente, comprobar cualquiera de estas propiedades se reduce a una
operación lógica y una comparación, lo que resulta mucho más simple que el
procedimiento anterior. Curiosamente, la tarea de inicializar la cadena de bits
correspondiente a un conjunto es más complicada que las operaciones sobre los
conjuntos y depende de cada caso. Normalmente hay que construir una máscara
individualizada para cada elemento con el fin de poner a 1 los bits que
correspondan en la cadena. Dentro de las operaciones lógicas también deben
considerarse los desplazamientos, que pueden definirse mediante la expresión
di ← di+k
donde di representa a cada uno de los bits del operando y k es el número de
lugares que se desplaza. En función del signo de k, el desplazamiento puede ser a
la izquierda (k negativo) o a la derecha (k positivo), donde se está suponiendo que
los bits se numeran de derecha a izquierda. Los desplazamientos pueden ser de
tres tipos: lógicos, aritméticos y rotaciones o desplazamientos circulares
dependiendo del bit entrante. El desplazamiento lógico a la derecha difiere del
aritmético en que el bit entrante es, en éste último, el mismo bit de mayor peso (bit
de signo), mientras que en aquél es siempre un 0; Así se consigue que los
desplazamientos aritméticos sean equivalentes a multiplicaciones (izquierda) y
divisiones (derecha) por 2. En las rotaciones el valor del bit entrante es el mismo
que el del saliente.

Ilustración 24 Empaquetamiento de caracteres.

Ilustración 25 Desempaquetamiento de caracteres.

Una aplicación en que se combinan muchas de las operaciones lógicas anteriores

es el empaquetamiento y desempaquetamiento de caracteres. Imaginemos la
situación mostrada en la figura 4.5 en la que tenemos, en un registro R, 4
caracteres x, y, z y t y que, en otro registro S, tenemos un carácter a que
queremos que sustituya, por ejemplo, al carácter z. En primer lugar, efectuaremos
una operación AND entre el registro R y una máscara con 0 en los lugares
ocupados por el carácter z y 1 en el resto, con lo que tendremos los caracteres x,
y y t inalterados y los lugares correspondientes al carácter z puestos a 0; después
sólo quedará realizar una operación OR entre este resultado y el registro S
desplazado convenientemente para que el carácter a quede alineado con el
carácter z que queremos sustituir. Una técnica parecida se puede emplear para
desempaquetar caracteres (figura 4.6): supongamos que del registro R original del
ejemplo anterior queremos extraer el carácter y; para ello construiremos una
máscara con 1 en los lugares ocupados por el carácter y y 0 en el resto y luego
haremos una operación AND entre esa máscara y el registro R. Después sólo
tendremos que desplazar convenientemente el resultado para obtener el carácter
deseado.

Instrucciones de control del flujo de programa

Las instrucciones de control de flujo son las que modifican el secuenciamiento de
la ejecución de las instrucciones del programa. En general, el secuenciamiento es
implícito, es decir, la siguiente instrucción en ejecutarse es la que está físicamente
detrás en el programa. Cuando esto no es así es por la acción de una instrucción
de control de flujo.
Ilustración 26Secuencia lineal de ejecución de instrucciones.

Ilustración 27Secuencia con puntos de discontinuidad en la ejecución de instrucciones.

la siguiente instrucción en ejecutarse es la que está físicamente detrás en el

programa. Cuando esto no es así es por la acción de una instrucción de control de
flujo. Todas las instrucciones que modifican el flujo de la ejecución manejan el
contador de programa. También, si la modificación del flujo de instrucciones se
hace de forma condicional, esta condición vendrá dada por los bits de estado (N,
Z, V y C). Vemos, por tanto, que para las instrucciones de control de flujo hay dos
variables fundamentales: el contador de programa y los bits de condición. Las
instrucciones de control de flujo suponen discontinuidades en la secuencia lineal
de ejecución de las instrucciones
Instrucciones de bifurcación La mayoría de los programas requieren de los
ordenadores en que se ejecutan la capacidad de examinar datos y luego alterar la
evolución del programa en función de los resultados de esa comprobación esto
nos lleva a la necesidad de la existencia de instrucciones de salto o bifurcación
que pueden ser de dos tipos: condicionales e incondicionales. Las bifurcaciones
incondicionales se realizan siempre, mientras que las bifurcaciones condicionales
se realizan o no en función del valor de uno o varios de los bits de estado o
condición, simbólicamente, de forma general

Ilustración 28Bifurcación condicional.

En esta representación, Condicion´ simboliza una expresión que involucra a uno o

más bits de condición. Los bits de condición más usuales son:
N: Bit que indica si el resultado de la última operación ha sido negativo.
Z: Bit que indica si el resultado de la última operación ha sido cero.
V : Bit que indica si en la última operación hubo desbordamiento.
C: Bit que indica si en la última operación se produjo acarreo o llevada
Algunas máquinas incluyen otros bits de estado adicionales. Es importante
distinguir la diferencia entre los bits C y V : mientras C indica que ha habido
llevada en el bit de orden más alto, V señala que el resultado de una operación
tiene demasiados bits para ser representado. En las operaciones realizadas en
binario natural ambos conceptos coinciden, sin embargo, en aritmética de
complemento a 2 son conceptos diferentes ya que la llevada en el bit de orden
más alto no es, en este caso, una situación incorrecta y se produce con mucha
frecuencia sin que haya desbordamiento. Veremos a continuación cómo se realiza
la detección de desbordamiento para dar el valor correcto al bit V . La operación
que puede dar más problemas de desbordamiento es la suma (o derivados, como,
por ejemplo, el incremento). En principio, el desbordamiento se produce, en una
operación en complemento a 2, cuando se suman dos operandos del mismo signo
y el resultado de la suma es de signo contrario. Esto se origina porque, al
desbordarse la capacidad del registro, se invade el bit de signo; por otra parte, no
habrá peligro de desbordamiento si se suman dos operandos de signo contrario ya
que, si ambos operandos caben en un registro su diferencia también cabrá. Estas
observaciones nos llevan a dar valor al bit V por una de las siguientes ecuaciones
lógicas:
V = (S1 ⊕ S2).(S1 ⊕ SR

V = SR S1 S2 + SR S1 S
Ilustración 29 Tabla de verdad de la suma para el bit de signo

En estas ecuaciones S1, S2 y SR son, respectivamente, los signos de ambos

operandos y del resultado.
Esta forma de detectar el desbordamiento tiene el inconveniente de que involucra
a demasiadas variables. Vamos a tratar de encontrar otro método que nos lleve a
una ecuación más simple. Para ello partiremos de la tabla de verdad de la suma
que se muestra en la tabla 4.1. Aplicando esta tabla al bit de signo (bit de orden n
− 1), que en las operaciones en complemento a 2 se trata igual que los demás, se
puede deducir de lo anterior, que en las filas de la tabla donde los dos sumandos
(xn−1 e yn−1) sean iguales y el resultado (sn−1) sea diferente tendremos
desbordamiento (V = 1). De la tabla podemos deducir que el valor del bit V viene
dado por:
V = xn−1yn−1cn−1 + xn−1yn−1cn−1
Esto podría ser una forma de determinar por hardware la existencia de
desbordamiento; sin embargo, a la vista de la tabla, puede deducirse que se
produce desbordamiento si la llevada entrante al bit de signo es diferente de la
saliente, es decir:
V = cn−1 ⊕ cn
Esta ecuación es más simple que la anterior para detectar el desbordamiento por
hardware. Este método tiene, además, la ventaja de que también es válida para
otras operaciones como, por ejemplo, los desplazamientos. En cuanto al
posicionamiento de los demás bits de estado, es bastante simple: N y C se
detectan directamente a partir de la unidad aritmética y Z se consigue mediante
una puerta NOR cuyas entradas sean todos los bits del resultado. Los conjuntos
de instrucciones de las máquinas suelen facilitar instrucciones auxiliares para
posicionar los bits de estado sin alterar el resto de los registros de la máquina,
estas instrucciones son (compara con 0) y (compara dos números restándolos).
Suele ser conveniente utilizar estas instrucciones inmediatamente antes de las
instrucciones de bifurcación condicional, ya que si, entre las instrucciones de
comparación y las de bifurcación, se insertan otras instrucciones los bits de estado
cambiarán y la comparación quedará sin efecto. Hay que señalar que en algunos
procesadores RISC (por ejemplo, SPARC) la mayoría de las instrucción
no cambian los flags, sólo los cambian instrucciones específicas. Esto es así
porque, en este tipo de procesadores, es frecuente tener que cambiar el orden de
ejecución de las instrucciones. En estos procesadores no es necesario que las
instrucciones de comparación estén inmediatamente antes que las de bifurcación.
Atendiendo al modo de direccionamiento utilizado para expresar la dirección de
continuación de la ejecución, las bifurcaciones pueden ser absolutas y relativas.
Son bifurcaciones absolutas aquéllas en que se especifica la dirección de la
instrucción donde debe continuar la ejecución del programa, normalmente, a este
tipo de bifurcaciones se les denomina saltos. Se llaman bifurcaciones relativas a
aquéllas en que se especifica la diferencia entre el nuevo valor del contador de
programa, es decir la dirección donde debe continuar la ejecución, y su valor
actual. Simbólicamente una bifurcación relativa funcionaría así:
En las máquinas en que las instrucciones deben estar obligatoriamente alineadas,
el desplazamiento suele multiplicarse por el tamaño de la palabra básica de
instrucción para permitir rangos mayores en este tipo de bifurcaciones. Las
bifurcaciones relativas facilitan la relocalización de los programas, por ello deben
utilizarse siempre que sea posible

Iteracione

Es muy frecuente que se necesite ejecutar un grupo de instrucciones cierto

número de veces , por ello, la mayoría de las máquinas tienen instrucciones
específicas para ello. Un método para realizar iteraciones se basa en poner un
valor inicial en un registro para luego pasar a ejecutar el código de la iteración, la
última instrucción del bucle actualizará el valor del registro y comprobará si se
cumple la condición de terminación, si es así se ejecutará la siguiente instrucción y
si no se comienza una nueva iteración. Esta forma de actuar se caracteriza por
hacer la comprobación de la condición al final del bucle por lo que éste se ejecuta
una vez como mínimo en todos los casos, incluso aunque la condición de
terminación se cumpla antes d entrar. Se puede analizar también la condición al
principio del bucle pero esto emplea algunas instrucciones más. En lenguaje
máquina lo que se suele hacer es poner en un registro el número de veces que se
debe iterar, antes del comienzo del bucle. Al final del bucle se decrementa el
registro y se compara con 0: si es 0 se continúa con la siguiente instrucción y si
no, se ejecuta otra vez el bucle desde el comienzo. Normalmente, la mayoría de
las máquinas tienen alguna instrucción para realizar estas dos últimas operaciones
con una sola instrucción ( en el PDP-11, y otras en el VAX, en el Z-80,
 en el 8086, etc.). Muchas máquinas, además de las instrucciones para
implementar bucles, tienen también instrucciones para realizar operaciones con
bloques y cadenas, lo que evita la ejecución de muchos bucle

Procedimiento

La técnica principal para estructurar programas es el uso de procedimientos que,

según el lenguaje, también se llaman subprogramas, subrutinas o funciones.
Desde el punto de vista de la máquina, una llamada a un procedimiento altera el
flujo de instrucciones como un salto con la diferencia importante de que el
procedimiento devuelve el control a la instrucción siguiente a la llamada una vez
que se ha concluido (figura 4.11). Sin embargo, desde el punto de vista de un
programador de lenguaje de alto nivel, la llamada a un procedimiento puede
considerarse como la ejecución de una instrucción de otro nivel; desde este punto
de vista, una llamada a un procedimiento puede considerarse como una simple
instrucción, aunque pueda ser bastante complicada. Definiremos un procedimiento
como una secuencia de instrucciones que realiza una tarea y a la que se puede
llamar desde diversos puntos del programa. Uno de los problemas planteados por
los procedimientos es el retorno a la siguiente instrucción a la llamada: debe
tenerse previsto un lugar seguro para guardar la dirección de la siguiente
instrucción (dirección de retorno) ya que, al pasar el control al procedimiento, esta
dirección desaparece del P C. Puede haber diversas soluciones: la más elemental
es reservar un registro o dirección de memoria para guardar la dirección de
retorno; este método tiene el inconveniente de que, si el procedimiento llamara a
otro (anidamiento), esta llamada haría que se perdiera la dirección de retorno de la
primera. Una mejora de este método consiste en que la instrucción de llamada a
procedimiento almacene la dirección de retorno en la primera palabra del
procedimiento, estando la primera instrucción ejecutable en la palabra siguiente; el
procedimiento
podría retornar mediante una instrucción de salto con direccionamiento indirecto a
la primera palabra del procedimiento. Con este método, el procedimiento podría
llamar a otros, ya que cada uno tiene sitio para una dirección de retorno. Si el
procedimiento se llamara a sí mismo (recursión), este esquema fallaría ya que la
segunda dirección de retorno destruiría a la primera. La recursión es una
característica muy importante por lo que este método no se emplea. Tampoco
sería válido este esquema para la recursión indirecta, es decir en el caso de que
un procedimiento A llamara a otro B y éste llamara a su vez a A. La mejor solución
al problema de la dirección de retorno, y por otra parte la más frecuente, es
guardar la dirección de retorno en una pila antes de efectuar el salto al
procedimiento; cuando el procedimiento concluya sacará la dirección de retorno de
la pila y la pondrá en el registro contador de programa. Este método no plantea
ningún problema a la hora de la recursión ya que salva la dirección de retorno por
encima de las anteriores, evitando su destrucción. Un problema similar se plantea
para guardar el estado del procesador que está materializado en sus registros;
éstos también deben guardarse en la pila, pero existen dos variantes en cuanto al
momento de hacerlo: puede ser el programa que llama el que guarde los registros
(caller-saving) o puede ser el procedimiento llamado quien lo haga (called-saving).
Existe una solución intermedia proporcionada por algunas arquitecturas en que no
hay que añadir instrucciones para guardar los registros puesto que la misma
instrucción de llamada lo hace, este es el caso de la arquitectura VAX en que la
primera palabra del procedimiento indica los registros que el procedimiento usa y
la instrucción de llamada los guarda. Otros problemas planteados por los
procedimientos son el paso de parámetros y el almacenamiento de sus variables.
Estos problemas se resuelven reservando en la pila lugar también para los
parámetros y las variables. Toda la información que se almacena en la pila cuando
se llama a un procedimiento se llama trama de pila o registro de activación del
procedimiento. Podrían arbitrarse otras soluciones para el paso de parámetros y el
almacenamiento de las variables del procedimiento (por ejemplo almacenarlas en
registros) pero estos métodos no funcionan correctamente para procedimientos
recursivos (la mayoría no lo son, y estos métodos pueden emplearse). En los
procesadores con ventanas de registros sí que pueden almacenarse los
parámetros y variables del procedimiento en registros, aunque sean recursivos, ya
que las ventanas hacen la función de la pila. Si se guarda demasiada información
en la trama de pila de los procedimientos resulta conveniente disponer de algún
apuntador auxiliar para referirse a las informaciones de la trama de pila sin recurrir
al apuntador de pila. Incluso existen computadores que poseen varios
apuntadores para estructurar la información de la trama de pila. La misión esencial
de este tipo de apuntadores es aportar la posibilidad de direccionar los
argumentos y las variables del procedimiento mediante desplazamientos referidos
al apuntador (que apunta a un lugar fijo de la trama de pila de cada
procedimiento). Este apuntador suele llamarse apuntador de trama (frame pointer,
F P). Con todos estos condicionantes la trama de pila tomará la forma de la figura
4.12. La secuencia de operaciones realizadas para llamar a un procedimiento
(secuencia de llamada) es la siguiente:
1. El programa que llama al procedimiento reserva en la pila lugar para los
argumentos.
2. La instrucción de llamada guarda en la pila la dirección de retorno y también se
guarda el valor del apuntador de trama del procedimiento anterior.
3. El procedimiento reserva en la pila lugar para sus variables.

Ilustración 30Trama de pila de dos procedimientos anidados.

Debe observarse que el orden de esta secuencia de acciones no puede alterarse y

este orden es el que causa el aspecto de la trama de pila (figura 4.12). Hay que
tener también en cuenta que en algún momento también habrá que guardar los
registros del procesador (esto no está representado en la figura 4.12). En el
momento del retorno se liberará el espacio ocupado en la pila por el procedimiento
y se cargará el contador de programa con la dirección de retorno guardada en la
pila. Asimismo se restaurará el contenido de los registros. La estructuración de los
programas exige muchas llamadas a procedimientos lo que hace de ellas uno de
los puntos más críticos a la hora de mejorar el rendimiento de la máquina; esto
hace que sea conveniente que las operaciones anteriores se realicen de la forma
más eficiente posible. Una alternativa para mejorar la velocidad en las llamadas a
procedimientos consiste en expandir el código del procedimiento en el lugar donde
ocurre la llamada. Este método, que es empleado a veces por algunos
compiladores, se denomina integración del procedimiento o procedimiento en línea
y puede usarse allí donde el tiempo de ejecución sea crítico. Sin embargo el
método tiene el inconveniente de que aumenta el espacio de memoria necesario
para el código, por ello puede ser una buena alternativa para procedimientos
cortos.

Ilustración 31Flujo de instrucciones en una llamada a procedimiento (a) y entre corrutinas (b).
Ilustración 32 Corrutinas.

Corrutinas
En la secuencia ordinaria de llamada a procedimiento la distinción entre el
procedimiento que llama y el llamado es clara. Consideremos el caso de dos
procedimientos que se llamen mutuamente. A primera vista esta situación se
podría considerar simétrica. La asimetría procede del hecho de que, cuando se
pasa el control del procedimiento que llama al procedimiento llamado, éste
comienza a ejecutarse desde el principio; sin embargo, cuando se produce el
retorno, la ejecución del procedimiento que hizo la llamada sigue en la instrucción
siguiente. Si se llamara más veces al procedimiento, éste comenzaría a ejecutarse
nuevamente desde el principio (situación mostrada en la figura (a)). La asimetría
se acentúa si analizamos el proceso llevado a cabo a nivel máquina: en el
momento de la llamada el valor del contador de programa pasa a la pila y cuando
el procedimiento retorna el proceso es justamente el contrario; además las
instrucciones que realizan ambas funciones son distintas. En algunas ocasiones
es útil tener dos procedimientos que se llamen el uno al otro como un
procedimiento (sin retorno) sin comenzar la ejecución desde el principio (figura
(b)). Dos procedimientos que llamen uno a otro de esta forma se denominan
corrutinas (figura). La forma de llevar a cabo en la práctica una llamada a una
corrutina es intercambiar los contenidos del contador de programa y de la cima de
pila, sin variar el apuntador de pila, ya que se saca un dato de la pila para meter
otro; de esta forma se intercambia el control entre las dos rutinas.

Desvíos o excepciones (traps)

Un desvío es un tipo especial de llamada automática a procedimiento iniciada por
alguna condición debida al programa. Hay que decir que la nomenclatura de la
literatura técnica cambia mucho de unos fabricantes a otros de forma que unos
llaman excepciones a lo que otros llaman interrupciones e incluso algunos llaman
a ambas cosas de la misma forma. Aquí trataremos de dar más importancia a los
conceptos que a los nombres. Los desvíos normalmente se deben a condiciones
importantes aunque no muy frecuentes. El caso más usual es la condición de
desbordamiento en operaciones aritméticas (TRAPV). Si después de una
operación se produce desbordamiento el microprograma lo detecta y bifurca a una
rutina de tratamiento de ese error. Usar esta técnica es más rápido que hacer una
bifurcación explícita en función de V después de cada instrucción aritmética ya
que la dirección de bifurcación es siempre la misma y el análisis de la condición,
en el caso del desvío, lo realiza automáticamente el microprograma después de
cada instrucción aritmética. También provocan desvíos la división por 0, la lectura
de un código de operación indefinido, el acceso a una palabra mal alineada en los
ordenadores en que la alineación es obligatoria, etc. Otro tipo de desvíos se
producen por causas debidas al sistema operativo tales como faltas de página,
errores de protección de segmentos, etc. También pueden existir desvíos para
funciones de depuración como puntos de ruptura, ejecución paso a paso, etc. Los
desvíos son recuperables si, después de tratarse con la rutina de excepción
adecuada, la ejecución puede continuar en la siguiente instrucción, y son no
recuperables si la ejecución del programa tiene que detenerse; en este caso,
habitualmente, se devuelve el control al Sistema Operativo de la máquina. Un
problema de los desvíos es encontrar la dirección del procedimiento, llamado
rutina de tratamiento de excepción. La vía mas usual de obtener esta dirección es
la vectorización que consiste en numerar todas las causas de desvío y tener una
tabla en memoria con todas las direcciones de las rutinas de tratamiento; estas
direcciones se denominan vectores y a la tabla anterior se la denomina tabla de
vectores de excepción. Si la tabla de vectores comienza en una dirección A y cada
vector ocupa t palabras, la dirección correspondiente a la excepción n vendrá dada
por: Direccion de la rutina de tratamiento del desvío n = (A + nt)
En esta expresión el paréntesis denota el contenido de la dirección de su interior.
El cálculo lo realiza internamente el procesador cada vez que se produce una
excepción, normalmente es un cálculo rápido ya que las constantes A e t facilitan
la tarea: normalmente t es una potencia de 2 y A muchas veces es 0, por lo que la
operación se reduce a un desplazamiento.

El Ciclo Indirecto
La ejecución de una instrucción puede involucrar a uno o más operandos en
memoria, cada uno de los cuales requiere un acceso a memoria. Además, si se
usa direccionamiento indirecto serán necesarios accesos a memoria adicionales.
Podemos considerar la captación de direcciones indirectas como un subciclo de
instrucción más.La principal línea de actividad consiste en alternar las actividades
de captación y ejecución de instrucciones. Después de que una instrucción sea
captada, es examinada para determinar si incluye algún direccionamiento
indirecto. Si es así, los operandos requeridos se captan usando direccionamiento
indirecto. Tras la ejecución se puede procesar una interrupción antes de la
captación de la siguiente instrucción.
Los pasos a seguir para el procesamiento de las instrucciones son los siguientes:

1. cada instrucción es leída ( una a la vez), desde la memoria, por el procesador.

2. cada instrucción es ejecutada por el procesador. La repetición de la lectura y
ejecución ( pasos 1 y 2 respectivamente), conforman la “ejecución de un
programa”. Dicha ejecución puede detenerse si: la máquina se apaga, ocurre un
error que no puede ser recuperado, o si, se encuentra una instrucción en el
programa que detenga la computadora.

Lectura y ejecución de instrucciones:

El procesador lee una instrucción de la memoria, al comienzo de cada Ciclo de

instrucción. Se cuenta con un contador de programas ( PC program counter ), que
lleva la cuenta de cual es la próxima instrucción a leer. Luego de leer cada
instrucción el procesador incrementara el PC, de manera tal que la siguiente
instrucción a leer será; la que se encuentra en la dirección inmediatamente
superior de la memoria. La instrucción leída es cargada en el registro de
instrucción ( IR instuction register ), que es un registro del procesador. El
procesador interpreta la instrucción, la cual está en forma de código binario, que
especifica la acción que el procesador llevará a cabo, y realizará la acción
requerida.

Ciclo de instrucción:
Un ciclo de instrucción (tambien llamado ciclo de traer y ejecutar) es el período de
tiempo durante el cual un ordenador lee y procesa una instrucción de lenguaje
máquina de su memoria o la secuencia de acciones que la unidad central (CPU)
funciona para ejecutar cada instrucción de código de máquina en un programa.
El nombre el ciclo traer-y-ejecutar comúnmente es usado.La instrucción debe ser
traída de la memoria principal, y luego ejecutado por la CPU.Esto es
fundamentalmente como un ordenador funciona, con su lectura de CPU y
ejecución de una serie de instrucciones escritas en su lenguaje máquina.De esto
surgen todas las funciones de un ordenador familiar a partir del final del usuario.
La CPU de cada ordenador puede tener ciclos diferentes basados en juegos de
instrucción diferentes.
Para traer la instruccion desde la memoria principal la CPU presenta el valor de la
PC sobre el bus de dirección.La CPU entonces trae la instrucción de la memoria
principal vía el bus de datos en el Registro de Datos de Memoria (MDR).El valor
del MDR entonces es colocado en el Registro de Instrucción Actual un circuito que
sostiene la instrucción de modo que pueda ser descifrado y ejecutado.

Memory Data Register (MDR)

Al decodificar la instrucción el decodificador de instrucción interpreta y pone en
práctica la instrucción.
Registros que son críticos al ejecutar la traída:
El registro de instrucción (IR) - mantiene la instrucción actual. La PC - sostiene la
dirección en la memoria de la siguiente instrucción a ser ejecutada.
Al traer archivos desde la memoria principal se lee la dirección eficaz de la
memoria principal si la instrucción tiene una dirección indirecta. Traer requiere
datos de la memoria principal para ser procesados y colocados en registros.

Ciclo de instrucción:
Del registro de instrucción, los datos que forman la instrucción son descifrados por
la unidad de control.
Pasa la información descifrada como una secuencia de señales de control a las
unidades de función relevantes de la CPU para realizar las acciones requeridas
por la instrucción como la lectura de valores de registros.
Los valores de registro pasan a la Unidad Aritmética lógica (ALU) para añadirlos
juntos y escribiendo el resultado de vuelta al registro. Una señal de condición es
enviada de regreso a la unidad de control por ALU si está implicado.
El resultado generado por la operación es almacenado en la memoria principal, o
enviado a un dispositivo de salida. Basado en la regeneración de condición del
ALU, la PC es incrementada para dirigir la siguiente instrucción o para actualizar a
diferentes direcciones de donde será traída la siguiente instrucción. El ciclo
entonces es repetido.
Ciclo de ejecución:
Proceso de memoria. La informacion es tranferida entre el CPU y el modulo I/O.
Proceso de datos usa operaciones matemáticas así como operaciones lógicas en
la referencia a datos.Alteraciones centrales
Una secuencia de operaciones, por ejemplo un salto la operación.
El último paso es una operación combinada de todos los otros pasos.

Hay siete tipos diferentes de ciclos de maquina en el 8085

Búsqueda de cop. Op
Lectura de MEMORIA
Escritura a MEMORIA
Lectura de E/S
Escritura a E/S
Respuesta a interrupción
Bus inactivo
La función básica que realiza un computador es la ejecución de un programa. Un
programa consiste en un conjunto de instrucciones y datos almacenados en la
unidad de memoria. La CPU es la encargada de ejecutar las instrucciones
especificadas en el programa.

La secuencia de operaciones realizada en la ejecución de una instrucción

constituye lo que se denomina ciclo de instrucción.

La culminación de cada una de estas fases necesita de una a seis ciclos de reloj.

EXECUTION
Durante una operación normal, el procesador busca secuencialmente y ejecuta
una instrucción tras otra, hasta que se procesa una instrucción (HALT) de paro. La
búsqueda y ejecución de una instrucción constituyes el ciclo de instrucción, que
representa a su vez una o más operaciones de acceso a memoria o a dispositivos
de E/S. cada acceso a memoria requiere un ciclo de máquina.
EJEMPLOS DE CILOS EN MAQUINAS

Es la acción de leer una instrucción en la CPU y prepararla para su ejecución se

denomina ciclo de captación.

Para completar una instrucción la CPU de codifica el opcode, que genera las
señales de control que se necesitan para introducir los operadnos requeridos y
controla la ejecución de la instrucción.

Durante el ciclo de captación, el opcode de la siguiente instrucción es cargado en

el IR(Registro de Instrucción) y la porción de dirección es cargada en el
MAR(Registro de Dirección de Memoria): esta instrucción puede ser tomada del
IBR(Registro de Buffer de Instrucción), o puede ser obtenido de la memoria
cargando una palabra en el MBR(Registro de Buffer de Memoria), y después al
IBR, IR, y MAR

CONJUNTO DE INSTRUCCIONES
Un conjunto de instrucciones o repertorio de instrucciones, juego de instrucciones
o ISA (del inglés Instruction Set Architecture, Arquitectura del Conjunto de
Instrucciones) es una especificación que detalla las instrucciones que una CPU de
un ordenador puede entender y ejecutar, o el conjunto de todos los comandos
implementados por un diseño particular de una CPU. El término describe los
aspectos del procesador generalmente visibles a un programador, incluyendo los
tipos de datos nativos, las instrucciones, los registros, la arquitectura de memoria y
las interrupciones, entre otros aspectos.

Existe principalmente de 3 tipos: CISC (Complex Instruction Set Computer), RISC

(Reduced Instruction Set Computer) y SISC (Specific Instruction Set Computer).

Los procesadores de los microcontroladores PIC son de tipo RISC.

La arquitectura del conjunto de instrucciones (ISA) se emplea a veces para
distinguir este conjunto de características de la microarquitectura, que son los
elementos y técnicas que se emplean para implementar el conjunto de
instrucciones. Entre estos elementos se encuentras las microinstrucciones y los
sistemas de caché.

Características generales de los conjuntos de instrucciones

Ante el diseño de un nuevo ordenador de propósito general hay que plantearse la

siguiente cuestión: ¿Qué tipos de instrucciones deben ser incluidos en su
conjuntos de instrucciones? Antes de responder a esta pregunta, analizaremos las
características que deben tener los juegos de instrucciones de las máquinas. Los
conjuntos de instrucciones de las máquinas deben tender a poseer una serie de
propiedades, bastante ideales e imprecisas, que pueden resumirse en las
siguientes:
 El conjunto de instrucciones de un computador debe ser completo en el
sentido de que se pueda construir un programa para evaluar una función
computable usando una cantidad de memoria razonable y empleando un
tiempo moderado, es decir, el número de instrucciones de ese programa no
debe ser demasiado elevado.
 Los juegos de instrucciones también tienen que ser eficientes, esto significa
que las funciones más necesarias deben poder realizarse usando pocas
instrucciones.
 El conjunto de instrucciones de una máquina debe ser regular, es decir
debe ser simétrico (por ejemplo, si existe una instrucción de
desplazamiento a la izquierda, debe haber otra de desplazamiento a la
 derecha, etc.) y ortogonal, es decir, deben poder combinarse, en la medida
de lo posible, todos las operaciones con todos los tipos de datos y modos
de direccionamiento.
 En muchas ocasiones, también se le debe exigir a un computador que su
juego de instrucciones sea compatible con modelos anteriores.

Tipos de instrucciones

Una máquina puede llegar a funcionar con un juego de instrucciones muy limitado
(recuérdese, por ejemplo, la máquina de Turing que sólo tiene 4 instrucciones,
incluso se han diseñado máquinas teóricas con menos instrucciones), esto
simplificaría mucho los circuitos de la máquina. Sin embargo, un conjunto de
instrucciones demasiado simplificado origina, como consecuencia, unos
programas demasiado complejos e ineficientes. Es necesario encontrar un
compromiso entre la simplicidad del hardware y del software. Un mínimo para
llegar a ese compromiso se consigue con los tipos de instrucciones siguientes:
 Instrucciones de transferencia de datos.
 Instrucciones aritméticas.
 Instrucciones lógicas.
 Instrucciones de control del flujo del programa (bifurcaciones, bucles,
procedimientos, etc.)
 Instrucciones de entrada y salida.

En los apartados siguientes iremos viendo con detalle algunos de estos

tipos de instrucciones. Si bien es cierto que el conjunto de instrucciones
debe de cumplir unos mínimos para conseguir una mínima eficiencia en los
programas, también se verá que ésta no se aumenta indefinidamente al
incrementar el número de instrucciones de la máquina.

Instrucciones de transferencia de datos

La operación de copiar datos de un lugar a otro es la operación más simple y a la
vez importante. Las palabras mover o cargar que aparecen en los juegos de
instrucciones de muchos ordenadores pueden dar lugar a confusión porque no se
trata de mover o cargar sino de copiar (generalmente, en Informática, la palabra
mover tiene el significado de copiar borrando el original). Las instrucciones de
transferencia de datos necesitan que se especifiquen el original (fuente u origen) y
el lugar donde se desea la copia (destino). Esta especificación variará según sean
estos lugares que pueden estar en tres sitios: registros del procesador, memoria o
cima de pila. Si el acceso es a una dirección de memoria habrá que especificarla
de forma explícita, si se trata de la cima de pila normalmente la especificación será
implícita, lo mismo ocurrirá si se trata del acumulador. Existen algunas variantes
de instrucciones de transferencia de datos que difieren de la idea anterior de
copiar informaciones de un lugar a otro. Por ejemplo, la instrucción POP saca un
dato de la cima de pila modificando el valor del apuntador de pila, lo que significa
que, si bien no
destruye físicamente el dato fuente, anula su validez. Por otro lado, la mayoría de
las máquinas también disponen de instrucciones de intercambio (SWAP).
También, en muchas máquinas, existen instrucciones de transferencia de
información entre bloques o cadenas en la que deben especificarse las
direcciones de fuente y destino y la longitud del bloque o cadena. En general, el
dato a transferir podríamos definirlo como una terna con las siguientes
componentes:

 Dirección
 Tipo
 Valor

Normalmente la componente del dato que se transfiere es el valor pero existen

instrucciones especiales para transferir las demás componentes, en especial la
dirección. La extracción de la dirección de un dato se hace necesaria para facilitar
la relocalización de los programas. Para aplicar muchos modos de
direccionamiento (indexados, autoindexados, etc.) es necesaria la transferencia de
una dirección a un registro. En muchos ordenadores esta dirección no se conoce a
la hora de compilar el programa (precisamente porque el programa es
relocalizable), por tanto, son necesarias instrucciones que calculen la dirección de
un dato para transferirla a un registro, actualmente la mayoría de las máquinas
poseen este tipo de instrucción bajo el nombre de move address. Dependiendo del
nivel de ortogonalidad de la máquina, podemos tener más o menos instrucciones
de transferencia. Por ejemplo el IBM-370 tiene más de 20 instrucciones de
transferencia por su falta de ortogonalidad; sin embargo, el PDP-11 sólo tiene 2
para datos enteros (MOV y MOVB) y 4 más para datos en punto flotante, ya que
en las instrucciones de punto flotante se prescindió bastante de la ortogonalidad
por falta de espacio para la codificación. El MC68000 está en un punto intermedio,
tiene varios formatos distintos dependiendo del direccionamiento utilizado. El Z-80
en cuanto a instrucciones de transferencia entre registros es bastante ortogonal,
pero esa ortogonalidad se pierde cuando se trata de otros direccionamientos.
Instrucciones aritméticas y lógicas

la utilidad de este tipo de operaciones es evidente y no la comentaremos. En

cuanto a las operaciones lógicas (AND, OR, NOT y XOR) tienen un uso muy
variado: desde operaciones con bits individuales (TEST, SET, RESET y CHANGE)
hasta el empaquetamiento y desempaquetamiento de caracteres. También
pueden considerarse dentro de este grupo los desplazamientos y rotaciones cuya
utilidad queda fuera de toda duda. En primer lugar, veremos cómo se emplean las
instrucciones lógicas para realizar operaciones de bit individual. La utilidad de
estas operaciones es muy variada, probablemente su aplicación más importante
sea empaquetar en un byte varias variables booleanas, ocupando cada una de
ellas un solo bit. Para analizar un determinado bit se debe tener en cuenta las
siguientes propiedades de la operación AND (. o ∧):
 Interrupciones

Las interrupciones son llamadas automáticas a procedimiento no debidas al

programa sino a una causa exterior. La diferencia entre las interrupciones y los
desvíos es que éstos son provocados por el mismo programa mientras que las
interrupciones son provocadas por causas externas de forma totalmente
asíncrona. Normalmente las causas de interrupción están relacionadas con las
operaciones de entrada y salida. Una interrupción detiene el programa en curso y
transfiere el control al procedimiento de tratamiento de la interrupción denominado
rutina de servicio de interrupción; cuando esta rutina concluye se debe devolver el
control al proceso interrumpido que debe continuar su ejecución en el mismo
estado en el que estaba cuando se produjo la interrupción. Esto significa que se
deben salvar el estado del procesador (es decir el contenido de los registros)
antes de comenzar la ejecución de la rutina de servicio y restaurarse al finalizar
ésta. Las interrupciones son necesarias cuando las entradas o salidas pueden
desarrollarse en paralelo con la ejecución de instrucciones en el procesador. Esto
normalmente es así debido a que, mientras un dispositivo de entrada/salida
efectúa una sola operación, el procesador puede ejecutar muchas instrucciones
convencionales. Los sistemas de interrupciones permiten que la CPU funcione
concurrentemente con los dispositivos de entrada y salida, siendo las
interrupciones el sistema de comunicaciones entre ambos procesos para que el
procesador sepa cuando el dispositivo de entrada/salida ha concluido. El
mecanismo de vectorización descrito en el apartado anterior también es válido
para encontrar la dirección de la rutina de servicio de interrupción. En las
interrupciones la diferencia radica en que el número de la interrupción lo manda el
propio dispositivo a través del bus de datos.
 Instrucciones de control de flujo en el VAX
En este apartado estudiaremos un caso concreto de instrucciones de control de
flujo: las correspondientes al VAX (Baase, 1983). Esta máquina tiene diversas
clases de instrucciones de control de flujo: Instrucciones de bifurcación El VAX
tiene dos instrucciones de bifurcación incondicional: y ; ambas instrucciones se
diferencian sólo en el tamaño del desplazamiento (1 o 2 bytes): para bifurcaciones
en que la dirección de destino se encuentre cerca de la dirección actual (menos de
128 bytes) se emplea , en caso contrario se emplea . En cuanto a las
bifurcaciones condicionales todas tienen un desplazamiento de 8 bits, esto limita
algo su uso y obliga en ocasiones a emplear una programación menos
estructurada en las bifurcaciones condicionales ya que es necesaria la
instrucción . En las instrucciones de bifurcación del VAX sólo se especifica el
desplazamiento, sin el byte de especificación de operando convencional en la
forma modo-registro. También existen instrucciones específicas para bifurcar en
función del valor del bit de orden más bajo de un operando (, branch if low bit set y
, branch if low bit clear: bifurca si el bit.
Ilustración 33 Instrucciones de bifurcación condicional en el VAX.

it 0 desactivado de orden más bajo es 1 ó 0 respectivamente), en estas

instrucciones, además del destino de la bifurcación, hay que especificar el
operando en que se analiza el bit en cuestión. En la tabla 4.2 puede verse un
resumen de las instrucciones de bifurcación condicional del VAX. Los nemónicos
terminados en corresponden a condiciones sobre números en binario natural (sin
signo) y las restantes a condiciones sobre números en complemento a 2 (con
signo). Existe una instrucción de salto incondicional (: jump, salto). La diferencia
entre esta instrucción y las bifurcaciones incondicionales reside en que en se
puede usar cualquier modo de direccionamiento para la dirección de destino y sin
embargo en las instrucciones de bifurcación esa dirección especifica siempre
mediante un desplazamiento. Instrucciones para el control de iteraciones En el
VAX existen diversas instrucciones para el control de iteraciones, unas se basan
en el decremento del índice (xxx: subtract one and branch if xxx, restar uno y
bifurcar si se cumple la condición xxx) y otras en su incremento (xxx: add one and
branch if xxx, sumar uno y bifurcar si se cumple la condición xxx). Existe también
una instrucción ( x: add, compare and branch, sumar, comparar y bifurcar) que
permite un incremento diferente de 1 que, además, puede ser tanto positivo como
negativo e incluso no entero. En la tabla 4.3 se muestran las instrucciones de
control de iteraciones del VAX. Llamadas a subrutinas y procedimientos En el VAX
se puede distinguir entre llamadas a subrutinas y llamadas a procedimientos: la
diferencia estriba en que una llamada a subrutina simplemente guarda la dirección
de retorno en o; la pila y bifurca. Podríamos decir que una llamada a subrutina es
una bifurcación con retorno; sin embargo, una llamada a procedimiento es más
complicada porque exige pasar los parámetros, guardar el contenido de los
registros, etc. Para remarcar más la diferencia entre ambos conceptos, a las
subrutinas se les llama a veces subrutinas internas ya que se consideran parte del
programa que las llama. Las instrucciones para llamar a una subrutina son y que
se diferencian por el tamaño del desplazamiento (1 o 2 bytes). También existe la
instrucción (return from subroutine, retorno de subrutina) que recoge la dirección
guardada anteriormente en la pila, por o , y bifurca a ella. En cuanto a las llamadas
a procedimientos, en el VAX hay dos instrucciones para efectuarlas: y . La
diferencia entre ambas radica en la forma de pasar los argumentos: mientras que
en se pasan a través de la pila con el fin de facilitar la recursión, en los
argumentos se pueden pasar en otra zona de memoria.

Ilustración 34 Instrucciones para el control de iteraciones del VAX

a de memoria. La sintaxis de estas instrucciones es: número de argumentos,

dirección del procedimiento dirección de la lista de argumentos, dirección del
procedimiento En lenguaje ensamblador las direcciones que aparecen es estas
instrucciones se representan mediante etiquetas. Si se utiliza la instrucción los
argumentos deben ponerse previamente en la pila en orden inverso mediante las
instrucciones
 (argumento por valor) o
x (argumento por referencia). Sin embargo, si se emplea la lista de argumentos
debe definirse previamente de la siguiente forma.

Ilustración 35 Lista de argumentos de un procedimiento en un VAX

Tanto si la llamada a procedimiento se realiza con ! como con ! la lista de

argumentos tiene la forma mostrada en la figura 4.15. La diferencia entre ambos
casos radica en que la lista de argumentos en el caso de ! reside en la pila y en el
caso de ! en cualquier lugar de memoria. En los dos casos el registro AP apunta al
comienzo de la lista de argumentos. También existe la diferencia en cuanto a la
forma de construir la lista de argumentos: mientras en el caso de ! los argumentos
se ponen mediante las instrucciones "#$ y "#$x y el número de parámetros lo pone
la misma instrucción ! (porque es uno de sus operandos), en el caso de !, la lista la
construye el usuario incluyendo el número de parámetros. Desde el punto de vista
del procedimiento no influye que la llamada se haya realizado mediante ! o !. De
hecho un mismo procedimiento puede llamarse de las dos formas (salvo que sea
recursivo). En ambos casos se hace referencia a los argumentos a través del
apuntador de argumentos (AP): %&"' el primero, (&"' el segundo, etc. si los
argumentos se pasan por valor o )%&"' el primero, )(&"' el segundo, etc. si se
pasan por referencia. La trama de pila para las llamadas a procedimientos del VAX
se muestra en la figura 4.16. Los pasos necesarios para estas llamada son las
siguientes:
Ilustración 36 Trama de pila de un procedimiento en el VAX.

1. Alinear la pila a doble palabra. Esto se consigue poniendo a 0 los

dos últimos bits del apuntador de pila. El valor anterior de estos bits
se guarda en un almacenamiento intermedio.
2. Salvar el contenido de los registros comprendidos en la máscara
situada en la primera palabra del procedimiento. Esta máscara la
construye el compilador. En lenguaje ensamblador los registros que
se deben salvar antes de entrar en el procedimiento se ponen en el
 directivo . A partir de esta información el ensamblador construye la
máscara. Por ejemplo, si un procedimiento altera los registros R2 y
R3 en su cabecera pondremos
3. Guardar en la pila los registros P C (contador de programa), F P
(apuntador de trama) y AP (apuntador de argumentos).
4. Guardar en la pila la PSW (palabra de estado), la máscara de
registros salvados, los dos bits menos significativos del apuntador de
pila (SP), antes de alinearlo, y un bit que indica si la llamada se ha
efectuado con 5. Poner a 0 la palabra de estado
6. Poner una doble palabra con 0 en la pila
7. Copiar el apuntador de pila (SP) en el apuntador de trama (F P).
8. Poner la dirección de la lista de argumentos en el registro AP
(apuntador de argumentos). En el caso de esta dirección es uno de los
operandos; sin embargo, en el caso de , antes de salvar los registros
(paso 2), se salva el número de argumentos y, en ese momento, el SP
es almacenado en un registro temporal para depositarlo ahora en el
registro AP
9. Cargar la dirección del procedimiento + 2 en el contador de programa
(el hecho de sumar dos a la dirección del procedimiento se debe a que
la primera palabra del procedimiento es la máscara de registro)
De forma análoga los pasos realizados por la instrucción (retorno de
procedimiento) son los siguiente
1. Copiar en SP el contenido de F P + 4. Esto elimina todas las
informaciones puestas en la pila después de la trama del procedimiento
(variables o informaciones apiladas que no se han eliminado antes).
2. Salvar la cima de pila (PSW, máscara de registros, etc) en un
almacenamiento intermedio
3. Restaurar los registros AP, F P y P C.
4. Restaurar los registros de uso general a partir de la máscara
guardada en el almacenamiento intermedio.
5. Se restauran los bits más bajos del SP (del almacenamiento
intermedio)
6. Se restaura la palabra de estado.
7. Si se usó se incrementa el apuntador de pila en 4(n + 1), siendo n el
número de argumentos que radica en la pila encabezando la lista de
argumentos, esto se realiza para eliminar los argumentos de la pila
Clases de variables En un programa de alto nivel, e incluso también en
lenguaje ensamblador, existe un concepto denominado visibilidad. Este
concepto se refiere al ámbito de validez del nombre de las variables.
Atendiendo a la visibilidad, los nombres de las variables pueden ser de
dos tipos: Globales: son nombres de variable reconocidos en todo el
programa. Locales: son nombres de variable que sólo se reconocen en
una parte del programa, normalmente uno o más procedimientos. El
ámbito de visibilidad de los nombres de las variables es un concepto
que maneja solamente el compilador, concretamente en la tabla de
símbolos haciendo que un símbolo sólo sea reconocido en su ámbito de
validez, y no transciende al código ejecutable del programa. Sin
embargo, hay otro concepto similar que es el de vida de la variable que
se define como el tiempo que transcurre desde que una variable se
comienza a usar hasta que se la menciona por última vez o, lo que es lo
mismo, el tiempo en que es necesario que la variable tenga espacio
reservado en memoria. Según este criterio las variables pueden ser de
tres tipos: Permanentes: son variables cuya vida es el tiempo total de
ejecución del programa. Estas variables se almacenan en una zona de
memoria accesible desde cualquier punto del programa denominada
área global. Se accede a este área con direccionamiento relativo o
direccionamiento por base y desplazamiento, tomando como base un
registro que apunte a la dirección de comienzo del programa. Un tipo
especial de variables de este tipo son las variables estáticas que son
variables permanentes cuyo nombre es local a uno o varios
procedimientos. Las variables estáticas conservan su valor aunque el
procedimiento retorne ya que también se almacenan en el área global.
Automáticas: son variables cuya vida es, como máximo, el tiempo de
ejecución del procedimiento donde se han definido. Los nombres de
estas variables son locales a ese procedimiento. Los parámetros de los
procedimientos se consideran variables de este tipo. Las variables
automáticas se almacenan en la pila, de esta forma su espacio se
reserva cada vez que se llama al procedimiento y es liberado cuando
retorna. El acceso a estas variables se realiza mediante
direccionamiento indexado al apuntador de trama de procedimiento o
frame pointer. En el caso de los parámetros pasados por referencia o de
las variables automáticas que representen apuntadores, se aplicará el
mismo direccionamiento pero en su versión indirecta. Dinámicas: son
variables cuyo espacio se reserva y libera durante la ejecución de un
procedimiento. Este tipo de variables se emplea para almacenar
estructuras de datos que pueden crecer o decrecer en ejecución tales
como listas enlazadas, árboles, etc. El lugar de almacenamiento de
estas variables se denomina área dinámica o heap y puede no ser
contiguo ya que el sistema operativo va concediendo memoria según el
programa la va solicitando y no siempre la memoria está disponible de
forma contigua. Las variables escalares de cualquiera de los tipos
anteriores pueden almacenarse en registros del procesador, salvo las
variables dinámicas y las variables automáticas en los procedimientos
recursivos, incluso en este caso también es posible en procesadores
RISC con ventanas de registros como se verá en el apartado
Direccionamiento de estructuras de datos
Una de las características fundamentales de los lenguajes de alto nivel
es la posibilidad de definir y manejar estructuras de datos complejas.
Estas estructuras plantean los siguientes problemas: Organizar su
almacenamiento en memoria. Encontrar la dirección de cada uno de sus
componentes más simples. En estas circunstancias el compilador del
lenguaje de alto nivel debe producir una secuencia de instrucciones para
calcular la dirección del componente deseado. El acceso a las
estructuras de datos más simples (un vector unidimensional, una
estructura o record, etc) puede requerir un número muy pequeño de
instrucciones si se utiliza la potencia de los modos de direccionamiento.
Por ejemplo, supongamos que queremos acceder al elemento k de un
vector cuyos elementos ocupan 2n bytes cada uno y están situados
consecutivamente en memoria; si el registro Rx contiene la dirección del
primer elemento y Ry contiene el índice (k), la dirección del elemento k
vendrá dada por Rx + [Ry << n] Si la dirección del primer elemento viene
dada por un desplazamiento respecto a otro registro, normalmente el
frame pointer o el propio P C, la expresión anterior, llamando
genéricamente Rref al registro de referencia, se convierte en: Rref +
desplazamiento + [Ry << n] Se puede usar direccionamiento indexado
para efectuar la suma, lo que nos eliminaría una operación. En el VAX el
direccionamiento indexado es tan potente que realiza toda la operación:
Si A es la dirección del primer elemento, especificada habitualmente
mediante direccionamiento relativo, el elemento k se especifica
mediante A[Ry] ya que el direccionamiento indexado del VAX multiplica
el índice por el tamaño del operando. También puede darse el caso de
 que la dirección del primer elemento venga dada por un apuntador, en
cuyo caso hay que añadir un nivel de indirección, con lo que queda:
(Rref + desplazamiento)+[Ry << n] En el VAX el direccionamiento
indexado soporta cualquier modo como índice, por lo que también se
puede aplicar sobre direccionamiento indirecto relativo, en este caso, el
elemento k del vector se especifica mediante . De una manera similar se
podría gestionar el acceso a elementos de matrices de varias
dimensiones
Un caso algo menos regular es el direccionamiento de estructuras de
datos tipo record o struct. La irregularidad reside en que el tamaño de
cada uno de los campos de una estrucutura de este tipo es diferente. En
este caso, la dirección de uno de los campos viene dada

En esta expresión, Rref + desplazamientoprimer elemento, representa la dirección

del primer elemento y desplazamientocampo, es el desplazamiento del campo
deseado respecto al primer elemento. Esto puede hacerse así, o, si el compilador
está optimizado, éste puede sumar ambos desplazamientos y utilizar
direccionamiento indexado simple. No puede hacerse esta última simplificación en
el caso de un apuntador a un struct(operador -> del lenguaje C) ya que, en este
caso, los dos primeros términos están afectados de una indirección y la dirección
del campo buscado es:

po Para este caso se adecúa muy bien el direccionamiento indirecto postindexado

del microprocesador MC68020. Una técnica similar puede usarse si una estructura
es un campo de otra. En este caso, para obtener la dirección de uno de los
campos de la estructura más interna, es necesario sumar tres desplazamientos: el
desplazamiento del primer campo de la estructura principal respecto al registro de
referencia, el desplazamiento del primer campo de la estructura interna respecto al
primer campo de la exterior y el desplazamiento del campo solicitado respecto al
primer campo de la estructura interna:

De la misma forma que en el caso anterior, con un compilador optimizado, se

pueden sumar todos los desplazamientos en compilación y aplicar
direccionamiento indexado simple. Si, por ejemplo, a la estructura externa se
accede a través de un apuntador, la dirección anterior se obtendrá mediante la
expresión:

De forma similar se puede actuar si alguno de los otros campos es un apuntador.

En este caso también pueden resultar interesantes los direccionamientos
indirectos preindexado y postindexado incorporados al microprocesador MC68020.

Tradicionalmente ha habido una gran diferencia de nivel entre el lenguaje máquina

y los lenguajes de alto nivel. Esta diferencia, conocida como barrera semántica o
brecha semántica, puede minimizarse de dos formas: aumentando la complejidad
de los compiladores o elevando la complejidad del lenguaje máquina. En general,
se ha optado por la segunda vía lo que, a lo largo del tiempo, ha llevado a
ordenadores con lenguajes máquina de muchas instrucciones y muy elaboradas
pero muy lentos debido a que un microprograma para decodificar muchas
instrucciones complejas será más lento que otro microprograma para decodificar
un conjunto mas reducido de instrucciones más simples; por otra parte, en este
último caso, el control puede ser cableado. Por otro lado, los programas escritos
en lenguajes de alto nivel no usan, tanto como se piensa, las instrucciones
complejas. Haciendo una estadística sobre programas escritos en lenguajes de
alto nivel, se puede llegar a la conclusión de que las instrucciones que más se
usan (más de un 90 %) son las asignaciones, las instrucciones condicionales (if,
while, etc), las llamadas a procedimientos y los bucles (for). También hay que
tener en cuenta que un porcentaje muy elevado de las asignaciones (alrededor del
80 %) no involucran a operaciones aritméticas, es decir, son asignaciones simples
(transferencias), aunque también se debe mencionar que algunas instrucciones
condicionales involucran también a operaciones aritméticas. En cuanto a las
llamadas a procedimientos, la mayor parte de ellas son llamadas con pocos
parámetros e incluso, en la mayoría de los casos, sin ellos. De una forma análoga
si analizamos el código máquina de los programas también se llega a una
conclusión similar respecto a los modos de direccionamiento utilizados: entre los
direccionamientos inmediato y por desplazamiento se cubre más de un 80 % de
las referencias a memoria de la mayoría de los programas (si bien esto depende
mucho del compilador utilizado). Quiere decirse con todo esto que los programas
escritos en lenguajes de alto nivel no usan apenas las instrucciones más
complejas, aunque en principio pudiera pensarse los contrario. Por ello cabe aquí
aplicar el principio de diseño "mejorar en lo posible los casos más frecuentes".
También hay que tener en cuenta que muchas máquinas están orientadas a un
solo tipo de aplicaciones (gestión, diseño asistido, cálculo científico, etc.), esto
hace que se puedan encontrar las instrucciones más necesarias para ese tipo de
aplicaciones concretas. Así se llega a los pasos de diseño de las máquinas RISC
(Reduced Instruction Set Computer: Computadores con conjunto reducido de
instrucciones): Analizar las aplicaciones que van a funcionar en esa máquina para
encontrar las operaciones más necesarias para esas aplicaciones (operaciones
clave). Diseñar el conjunto de registros y las comunicaciones entre ellos más
apropiados para la ejecución de las operaciones clave. Diseñar las instrucciones y
modos de direccionamiento para realizar las operaciones clave en el conjunto de
registros anteriormente diseñado. Añadir nuevas instrucciones sólo si no hacen
más lenta la máquina. Estos pasos de diseño tienen la estructura del llamado
diseño descendente, esto quiere decir que se analizan las especificaciones de lo
que se necesita y luego se va descendiendo hacia los elementos de más bajo
nivel necesarios para cumplir esas especificaciones. Ahora introduciremos el
concepto de ciclo máquina que es el tiempo necesario para extraer los operandos
de los registros, llevarlos a la ALU para operar con ellos y depositar el resultado en
un registro. Este tiempo de ciclo debe ser tan pequeño como sea posible, esto se
consigue sacrificando todo lo que incremente la duración del ciclo, por ejemplo,
deben eliminarse las instrucciones que tarden en ejecutarse más de un ciclo. Los
principios de diseño de los ordenadores con arquitectura RISC son los siguientes:
Relativamente pocas instrucciones y pocos modos de direccionamiento.
 Modos de direccionamiento y formatos.
Las instrucciones máquina son las acciones elementales que puede ejecutar un
computador. Una acción compleja deberá codificarse como una secuencia de
instrucciones máquina en lo que se denomina un programa. La arquitectura de un
procesador entendida como el conjunto de recursos operativos disponibles por un
programador a nivel de lenguaje máquina queda definida por el repertorio de
instrucciones (ISA: Instruction Set Architecture). En general, una instrucción
codifica una operación básica que el computador realiza sobre unos datos
ubicados en la memoria o en los registros de la máquina y a los que accede
utilizando un modo de direccionamiento. Por consiguiente, la arquitectura ISA de
un procesador viene determinada por los siguientes factores:
a) Tipos de datos y formatos que pueden manejar las instrucciones: naturales,
enteros,reales, caracteres, etc.
b) Modos de direccionamiento de los datos ubicados en la memoria: inmediato,
directo, indirecto, etc. Estos dos factores son determinantes para la
implementación eficiente de las estructuras complejas de datos de un lenguaje de
alto nivel.
c) Conjunto básico de operaciones que se pueden realizar sobre los datos: suma,
resta, etc.
Propiedad de ortogonalidad
Diremos que un repertorio es ortogonal cuando las instrucciones puedan
combinar los elemento de los tres factores anteriores sin ninguna restricción. La
ortogonalidad completa no se da en ningún repertorio de máquina real.
Ilustración 37 Tipo de dirrecionamiento

Formato de las instrucciones

Las informaciones relativas a los cuatro factores anteriores se codifican en cada
una de las instrucciones siguiendo un formato preestablecido. El formato
determinará la longitud en bits de las instrucciones y los campos que codifican el
valor de los factores citados. En general una instrucción se compone de los
siguientes campos:
• Código de operación (CO)
• Operandos fuente (OP1, OP2,...)
• Operando destino o Resultado (OPd)
• Instrucción siguiente (IS)
CO OP1 OP2 .......... OPd IS

El CO determina la operación que se realiza sobre OP1,OP2,... El resultado se

deja en OPd. Lo normal es que el número de operandos fuente de un repertorio no
pase de 2. La dirección de la instrucción siguiente IS queda implícita en todas las
instrucciones (se trata de la instrucción siguiente del programa) salvo en las
instrucciones de ruptura condicional o incondicional de secuencia.
Diseño del repertorio de instrucciones.
Los repertorios de instrucciones podemos clasificarlos atendiendo a los siguientes
criterios:
A) Número de operandos explícitos por instrucción
a) 3 operandos explícitos
CO OP1 (fuente 1) OP2 (fuente 2) OP3 (destino)
ejemplo: ADD B,C,A A Å B + C
• Máxima flexibilidad
• Ocupa mucha memoria si los operandos no están en registros
2 operndos explícitos
b) CO OP1 (fuente 1) OP2 (fuente
ejemplo: ADD B, C B Å B + C
• Reduce el tamaño de la instrucción
• Se pierde uno de los operandos
c) 1 operando explícito CO OP1 (fuente ejemplo: ADD B Acumulador Å + B
• Supone que fuente 1 y destino es un registro predeterminado (acumulador)
• Se pierde un operando fuente

d) 0 operandos explícitos
CO

ejemplo: ADD cima de pila Å + • Se trata de computadores que trabajan sobre

una pila
Ilustración 38 Ejemplo

B) Forma de almacenar operandos en la CPU

a) Arquitectura de pila (HP 3000/70)
b) Arquitectura de acumulador (Motorola 6809)
c) Arquitectura de registros de propósito general (IBM 360)
Ejemplo: código máquina en cada una de las tres alternativas correspondiente a la
sentencia de asignación C := A + B

Ilustración 39 Ejemplo2

Las arquitecturas de registros de propósito general se clasifican a su vez

atendiendo al número máximo de operandos (2 ó 3) que pueden tener las
instrucciones de la ALU y cuantos de ellos se pueden ubicar en memoria:
(operandos - en memoria)
( 3 - 0 ) Arquitectura registro-registro (también llamada de carga-almacenamiento).
Utilizan tres operandos totales y cero en memoria. Formato de longitud fija y
codificación simple de las instrucciones que pueden ejecutarse en un número
similar de ciclos. Facilitan un modelo simple de generación de código apara el
compilador. SPARC, MIPS, PowerPC
( 2 - 1 ) Arquitectura registro-memoria. Utilizan dos operandos totales con uno
ubicado en la memoria. Intel 80X86, Motorola 68000
( 3 - 3 ) Arquitectura memoria-memoria. Utilizan tres operandos totales con la
posibilidad de ser ubicados los tres en memoria. VAX

Códigos de operación de longitud fija y variable

Una máquina con un formato de instrucción que dedica n bits al CO permitirá n 2
instrucciones diferentes, cada una de las cuales puede tener diferente número de
operandos (0, 1, 2, 3, etc.). Los bits del campo OPERANDOS se pueden utilizar
para extender el CO de aquellas instrucciones con menor número de operandos.
Ejemplo: Partimos de una máquina con instrucciones de longitud fija de 24 bits y
consideraremos los siguientes supuestos: 1) La máquina dispone de 16 registros
generales 4 4 16
C R OP
En este caso se pueden codificar 16 instrucciones de 2 operandos: uno en registro
y el otro en memoria
2) Si queremos extender el CO se puede utilizar una de las 16
combinaciones del CO (quedarían 15 con 2 operandos), por ejemplo
CO = 1111, dando la posibilidad de codificar 16 instrucciones de 1
operando en memoria. Si queremos seguir extendiendo el CO
podemos utilizar CO = 1111 1111 (quedarían 15 con 1 operando)
para definir instrucciones sin operandos (216 = 65.536) En la
siguiente tabla se resume el proceso descrito.
Ilustración 40 Ejemplo 3

Optimización del CO variable en función de la frecuencia

de las instrucciones.
Una posibilidad a la hora de codificar las operaciones de un repertorio de
instrucciones es utilizar algún criterio de óptimo. En este sentido tenemos dos
alternativas: a) Frecuencia de aparición en el programa Î optimización de memoria
b) Frecuencia de ejecución en el programa Î optimización del tráfico CPU-Memoria
La alternativa b) es la más interesante en la actualidad, pues prima la velocidad de
ejecución sobre la memoria .necesaria para almacenar el programa. Para
optimizar el CO se puede utilizar la codificación de Huffman que veremos con el
siguiente Ejemplo: Supongamos las siguientes frecuencias de ejecución de 7 tipos
diferentes de instrucciones:
Ilustración 41Tipo de instruciones y frecuencia de ejecución

Con CO de longitud fija se necesitarían 3 bits. Para obtener el código de Huffman

procedemos de la siguiente manera: 1) Se escriben en una columna las
instrucciones y a su derecha su frecuencia de ejecución. Cada elemento de la
columna será un nodos terminal del árbol de decodificación. 2) Se unen las dos
frecuencias menores de la columna anterior con sendos arcos, obteniéndose un
nuevo nodo cuyo valor será la suma de los nodos de procedencia. 3) Se repite el
paso 2) hasta llegar a la raíz del árbol que tendrá valor 1 4) Comenzando en la
raíz, asignamos 0 (1) al arco superior y 1 (0) al inferior hasta llegar a los nodos
terminales 5) Se obtiene el código de cada instrucción recorriendo el árbol de la
raíz a la instrucción y concatenando los valores de los arcos del camino Para
nuestro ejemplo tendremos lo siguiente:
Ilustración 42 Codigo de Huffman

Propiedades generales del direccionamiento.

Resolución Es la menor cantidad de información direccionada por la arquitectura.
El mínimo absoluto es un bit, aunque esta alternativa la utilizan pocos
procesadores, por ejemplo, el iAPX432 de Intel (1981) Requiere un gran número
de bits para expresar las direcciones de una cierta cantidad de información y
mucho tiempo para alinearlos correctamente. Lo más frecuente en los
procesadores actuales es utilizar resoluciones de 1 o 2 bytes. La resolución puede
ser diferente para instrucciones y datos aunque lo normal es que coincida.

Ilustración 43Resolucion

Orden de los bytes en memoria El concepto de endian lo introdujo Cohen para

expresar la forma como se ordenan los bytes de un escalar de varios bytes. •
Modo big-endian: almacena el byte más significativo del escalar en la dirección
más baja de memoria • Modo little-endian: almacena el byte más significativo del
escalar en la dirección más alta de memoria. Ejemplo: el hexadecimal 12 34 56 78
almacenado en la dirección de memoria 184 tendrá la siguiente organización en
cada uno de los modos:

Ilustración 44Modos

Alineación Un objeto de datos de n bytes ubicado en la dirección de memoria D se

dice que está alineado si D mod n = 0

• Determinadas máquinas sólo permiten accesos alineados

• La falta de alineación implica complicaciones hardware
• Los programas con accesos alineados se ejecutan más rápidamente
• Para alinear datos se utiliza una red de alineación. En el caso de la figura para
acceder a una palabra no alineada serán necesarios 2 accesos para obtener la
parte alta y baja
 Espacios de direcciones
En un mismo procesador pueden diferenciarse hasta 3 espacios de direcciones
diferentes:
• Espacio de direcciones de registros
• Espacio de direcciones de memoria
• Espacio de direcciones de entrada/salida
Los espacios de direcciones de memoria y entrada/salida de algunos
procesadores están unificados (un solo espacio), ocupando los puertos de E/S
direcciones de ese espacio único. En estos procesadores (ejemplo, 68000) no
existen instrucciones específicas de E/S, para esta función se utilizan las de
referencia a memoria (carga y almacenamiento) con las direcciones asignadas a
los puertos.
 Modos de direccionamiento.
Los modos de direccionamiento determinan la forma como el operando (OPER)
presente en las instrucciones especifican la dirección efectiva (DE) del dato
operando (DO) sobre el que se realiza la operación indicada por CO. Inmediato.
DO = OPER
• El dato operando se ubica en la propia instrucción ==> no requiere accesos a
memoria.
• Se suele utilizar para datos constantes del programa
• El tamaño está limitado por el número de bits de OPER Implícito CO
• El dato operando se supone ubicado en algún lugar específico de la máquina,
por ejemplo, una pila Directo (memoria o registros)

• La especificación de un registro requiere menor número de bits que la de una

posición de memoria
• El acceso a los registros es más rápido que a Memoria
• El direccionamiento directo a memoria se conoce como absoluto
• A veces se limita el número de bits de OPER limitando el acceso a sólo una parte
de la memoria que suele ser la correspondiente a las direcciones más bajas
(página cero)

• Permite el tratamiento de una dirección de memoria como un dato

• Permite el paso por referencia de parámetros a subrutinas
• Permite referenciar un espacio mayor de direcciones
Ilustración 45 Direccion de un registro

Modos con desplazamiento.

Calculan la dirección efectiva (DE) sumando al contenido de un registro el
operando declarado en la instrucción (OPER) que se interpreta como un
desplazamiento respecto al contenido del registro. La distinta naturaleza del
registro hace que se diferencien tres modos con desplazamiento. Todos explotan
la proximidad de los datos o instrucciones referenciadas para utilizar menor
número de bits en el campo OPER.

Ilustración 46 Dirrecionamiento base mas desplazamiento

Este programa podremos reubicarlo en memoria y siempre llevará a la dirección
apuntada por el registro base RB la suma de los contenidos de las dos direcciones
siguientes.

Ilustración 47Resumen tipos de direccionamiento

Modos compuestos
Veremos los modos compuestos analizando el repertorio de algunos
procesadores. Modos de direccionamiento del MC 68.X
CO OPER
• Inmediato
DO = OPER
- enteros: 8, 16 y 32 bits
- reales: 32 bits (simple precisión), 64 bits (doble precisión) y 96 bits (precisión
extendida)
• Directo
- Memoria o absoluto
DE = OPER, DO = , con OPER de 16 y 32 bits – Registro
Ri = OPER, DO = , con Ri cualquier registro
• Indirecto
registro - puro DE = , con Ri cualquier registro
 conclusión
Con el presente trabajo arribamos a las siguientes conclusiones:

Conocer en detalles todas las operaciones que son capaces de realizar las CPU.

Nos permite facilitar para la realización de nuestro trabajo y estudio un una

investigación o escribir un texto o realizar un análisis estadístico, entre otros, y
saber y observar la operación fundamental de la mayoría de los CPU, que
posibilita ejecutar una secuencia de instrucciones almacenadas llamadas
"programa".

Los programas son representados por una serie de números que se mantienen en
una memoria del computador.
 Glosario
3DNow: Especificaciones multimedia para los procesadores de AMD.

Acceso Directo: Icono especial que representa a una carpeta o un archivo y que
abre o ejecuta ésta de una forma cómoda y rápida.

Acceso telefónico a redes: Aplicación que permite utilizar una línea telefónica y
un módem para conectarse a otro equipo.

Active Desktop: Escritorio activo de Windows 98 que permite tener contenido

activo en el Escritorio y poner como fondo o papel tapiz una página Web, un vídeo,
un sonido, etc.

Active X: Tecnología de Microsoft que proporciona contenido multimedia

(interactivo) a las páginas Web.

Actualizar: Volver a cargar o mostrar el contenido de una página Web o una

ventana.

ADC: Circuito para convertir la señal analógica en digital, es decir, para digitalizar.

Add-ons: Añadidos o módulos que se incorporan a los que ya se tienen y que

proporcionan nuevas funcionalidades.

ADSL (Asymmetric Digital Subscriber Line - Línea Digital Asimétrica de

Abonado): Sistema asimétrico de transmisión de datos sobre líneas telefónicas
convencionales.
AGP: Puerto acelerador gráfico. Bus que mejora la reproducción de gráficos en el
ordenador.

AIX: Versión del sistema operativo UNIX diseñada por IBM para estaciones de
trabajo y grandes sistemas.

Alfanumérico: Cualquier combinación de números, letras y símbolos.

Algoritmo: Conjunto de instrucciones concretas y detalladas mediante el cual se

consigue una acción determinada.

AMD: Empresa que fabrica los procesadores K6 o K6-2, competencia de Pentium

y Pentium II.

Ancho de banda: Máxima cantidad de información simultánea que se puede

transferir por una línea telefónica.

API (Aplication Program Interface - Interfaz de Aplicación del Programa):

Conjunto de rutinas del sistema que se pueden usar en un programa para la
gestión de entrada-salida de ficheros, etc.

Aplicación: Programa que realiza una serie de funciones y con el cual trabajamos
en el ordenador.

Applets: Programas desarrollados con Java para mejorar la presentación de las

páginas Web que realizan animaciones, juegos e interacción con el usuario.

Arbol: Estructura de directorios o carpetas de un ordenador, del directorio raíz van

partiendo diferentes ramas (subdirectorios o subcarpetas), donde se ubican los
archivos.
Arcade: Programas de acción (videojuegos) donde las armas o la violencia juegan
un papel importante.

Archivo: Documento generado con una aplicación que se almacena en una

unidad.

Arquitectura: Término que se refiere al tipo de estructura hardware de la máquina

y que también se aplica a la clasificación de los microprocesadores o el tipo de
ranuras de expansión.

Arrastrar: Dícese del movimiento generado por una selección al hacer clic sobre
ella y, sin soltar el botón del ratón, mover ésta hacia otro lugar.

ASCII (American Standard Code of Information Interchange): Estándar

reconocido que engloba un número de caracteres útiles.

Asistente: Herramienta que nos guía y ayuda a través de varios pasos a realizar
una tarea para mayor comodidad y sencillez.

Athlon: Nombre del último procesador de AMD que puede funcionar a velocidades
que oscilan desde los 500 a 700 MHz

ATM (Asyncronous Transmision Mode): Sistema de transferencia de datos

asíncrono que aprovecha al máximo la capacidad de una línea. Una de las
tecnologías de red más punteras, pero también cara.

Audio-CD: Calidad de sonido equivalente a la que proporciona un compact-disc y

que corresponde a 44 KHz a 16 bits en estéreo.
Autocompletar: Característica que funciona en distintas aplicaciones y que nos
completa operaciones utilizadas frecuentemente.

Autoedición: Programas para la edición y maquetación electrónica de

documentos que se han impuesto a los tradicionales sistemas de preimpresión.
Permiten crear y diseñar periódicos, revistas y todo tipo de publicaciones
(QuarkXPress, PageMaker...).

Autoexec.bat: Programa que carga automáticamente el sistema operativo al

arrancar, el cual puede modificar el usuario para personalizar el ordenador al
encenderlo.

Autopistas: Redes de comunicación global, como Internet, que constituyen los

nuevos canales de la información y de la cultura.

AVI: Formato de vídeo digital por excelencia en el mundo PC, desarrollado por
Microsoft.

Backbone: La columna vertebral de la Red.

Backup: Aplicación de copia de seguridad de ficheros, carpetas o unidades

completas que permite dividir la información o ficheros en varios disquetes y que
además la comprime.

Bajar: Descargar o transferir a nuestro ordenador archivos de Internet.

Barra de canales: Opción del Escritorio que proporciona una lista de los canales
disponibles en su equipo.
Barra de direcciones: Forma rectangular que aparece en la parte superior de las
ventanas y la cual nos informa en todo momento de la Path (trayectoria) donde
nos encontramos posicionados dentro de una unidad. En Internet es el lugar
donde hay que teclear la dirección de la página Web a la que deseamos acceder
para que el ordenador la cargue y la muestre en pantalla.

Barra de herramientas: Conjunto de botones que representan las opciones de

menú más comunes o las utilizadas con más frecuencia.

Barra de tareas: Forma rectangular gris que aparece nada más cargar Windows
98 en la parte inferior del Escritorio y la cual se divide en zona de control, el botón
Inicio, alguna barra de herramientas y la zona de carga de carpetas y aplicaciones.

Barra del explorador: Panel que se abre en la parte izquierda de las ventanas.

Base de datos: Sistema de almacenamiento de datos muy flexible que permite

organizar la información de forma muy eficiente.

Batch: Fichero de proceso por lotes, es un archivo que encadena comandos que
son realizados por el PC cuando se le invoca.

Baudio: Unidad de medida. Número de cambios de estado de una señal por

segundo.

Beta: Versión anterior a la Alfa y que puede ser la versión definitiva que se
comercializará en un determinado tiempo.

Binario: Código básico de la informática que reduce todo tipo de información a

cadenas de ceros y unos, que rigen las instrucciones y respuestas del
microprocesador.
BIOS: Información básica grabada en un chip imborrable que hace que un
ordenador pueda funcionar y arrancar./font>

Bit (binary digit): Unidad básica de información representada por ceros y unos
que se van sucediendo para conformar los distintos significados.

BMP (Bitmap): Formato de fichero gráfico por excelencia de los ordenadores PC,
inventado por Microsoft, que tiene mucha calidad y se lee rápidamente. En contra,
no se puede comprimir de ninguna manera y, generalmente, no es reconocido por
ningún ordenador que no sea PC.

Bookmark: Marca, anotación de una dirección Web oURL que queda archivada
para su posterior uso.

Botón Inicio: Botón que se encuentra a la izquierda de la barra de tareas del

escritorio y mediante el cual ejecutamos cualquier tarea (iniciar programas, abrir
documentos, obtener ayuda, buscar archivos o carpetas, configurar el sistema o
las impresoras...

Botón secundario: Botón derecho del ratón. Muestra un menú emergente o

contextual.

Browser: Navegador para poder visualizar las páginas Web en Internet.

Buffer: Memoria intermedia que se utiliza en distintos periféricos.

Bump mapping: Técnica por la cual se consigue dotar a las texturas de un relieve
simulado.
Bus: Especie de carretera por donde circulan los datos dentro del ordenador
comunicando a los diferentes componentes de la placa base, que dependiendo de
su tamaño harán que un ordenador tenga mayores o menores prestaciones, así
como una mayor o menor capacidad de transferencia del ordenador.

Buscador: Servidor de Internet que organiza los ficheros por grupos temáticos y
que permite la localización de páginas Web mediante unas palabras clave que
introduce el usuario, sin necesidad de conocer las direcciones de las citadas
páginas.

Bus Serie Universal (USB): Estándar de hardware para la conexión de

dispositivos externos, permite la instalación Plug and Play, de forma que puede
agregar nuevos dispositivos al equipo sin tener que agregar ni tarjetas
adaptadoras ni apagarlo.

Byte: Medida básica de capacidad en informática. Comprende 8 bits o

interruptores, cada uno de los cuales puede conmutar en dos posiciones ON y
OFF.

Caché: Carpeta o memoria intermedia que almacena temporalmente los archivos

del equipo.

CAD (Computer Aided Design): Diseño asistido por ordenador-

CAM: Fabricación asistida por ordenador.

Canal: Lugar Web que entrega el contenido de Internet en el ordenador. Los

canales copian automáticamente el contenido desde Internet al sistema cuando
nos suscribimos a un sitio.

Cancelmoose: Persona que declara la guerra al spamming.

Carpeta: Contenedor que sirve para almacenar archivos u otras carpetas.

Caudal: Cantidad de ocupación de un ancho de banda.

CD (Compact Disc): Disco compacto óptico, de 12 cms. de diámetro, que se

utiliza para almacenamiento binario.

CD-A: Compact-disc de música.

CD-R: Disco compacto sobre el que se puede escribir una sola vez.

CD-ROM: Disco compacto de sólo lectura, soporte de almacenamiento de datos

de gran capacidad

CD-RW: Disco compacto regrabable, que se puede escribir, borrar y reescribir

encima.

CD-Vídeo: Disco compacto que contiene imagen de vídeo, películas o clips

musicales.

Celeron: Versión de Pentium II de gama baja sin memoria caché externa.

CGI (Common Gateway Interfaces): Programa que reside y se ejecuta en el

servidor y que envía su salida al navegador de Internet del usuario, como, por
ejemplo, un formulario de envío.
Chat: Servicio de Internet basado en la comunicación en tiempo real y mediante
teclado entre personas.

Chatear: Función que permite conversar en tiempo real y dentro de Internet entre
personas situadas en distintos puntos del planeta mediante la utilización del
teclado.

Cheat code: Trucos para pasar los distintos niveles o pantallas de los
videojuegos.

Chip: Circuito integrado y encapsulado.

Chipset: Conjunto de chips que complementan el rendimiento del procesador

principal.

Chroma-key: Método de composición de vídeo que consiste en filmar actores

sobre un fondo de cierto color y luego sustituir ese color por otra imagen.

Ciberjuegos: Juegos a los que se puede acceder por Internet y que pueden ser
compartidos por los cibernautas.

Cibernauta: Internauta o navegante virtual que accede a cualquier tipo de

información disponible en la World Wide Web.

Cibernética: Ciencia que estudia el diseño de máquinas automáticas o robots con

objeto de dotarles de inteligencia humana.

Ciberocupas: Personas que registran el dominio (dirección de una página Web)

de un producto o del nombre de una empresa ajena, antes de que la propia
interesada lo haga, para después pedir a cambio una cantidad de dinero al dueño
legítimo.

CISC (Complex Instruction Set Computer): Procesador u ordenador cuyo juego

de instrucciones es complejo o amplio.

Bibliografía
https://es.wikipedia.org/wiki/Unidad_central_de_procesamiento
http://decsai.ugr.es/~dpelta/ProgOrdenadores/glosario.html
https://www.monografias.com/trabajos83/unidad-central-procesamiento-
cpu/unidad-central-procesamiento-cpu.shtml#conclusioa
http://itpn.mx/recursosisc/5semestre/arquitecturadecomputadoras/Unidad%20II.pdf
file:///C:/Users/kike/Desktop/cresto/conjunto.pdf

https://www.scoop.it › topic › 2013/11/04 › 2-2-3-ejemplos-de-organizacion...

http://itcv-arquitectura-de-computadoras.blogspot.com/2014/11/24-casos-de-
estudio-de-cpu-reales.html
http://www.portalhuarpe.com/Medhime20/Sitios%20con%20Medhime/Computaci
%C3%B3n/COMPUTACION/Menu/Modulo%205/5-6.htm
https://www.clubensayos.com/Tecnolog%C3%ADa/Arquitectura-De-
Computadoras/980310.html

[ CITATION pab11 \l 2058 ]

[ CITATION bus07 \l 2058 ]
[ CITATION mem \l 2058 ]
[ CITATION arq06 \l 2058 ]