Microprocesadores: La Evolución de la Computación con Programa Almacenado

En los albores de la computación, pioneros como Alan Turing y John von Neumann reconocieron que una máquina verdaderamente útil debe hacer más que meramente ejecutar una lista de comandos —debe poder almacenar, recuperar y modificar datos dentro del mismo depósito de memoria. Esta idea llevó al concepto de la computadora con programa almacenado.

La máquina teórica de Turing dependía de una cinta de acceso secuencial para guardar tanto instrucciones de programa como datos. Un circuito de control leía la cinta, realizaba operaciones, y reescribía resultados en la cinta o movía la cinta para leer nuevos datos. Sistemas modernos reemplazan esa cinta con memoria de acceso aleatorio (RAM), logrando el mismo propósito con mucha mayor velocidad y flexibilidad.

Una analogía útil viene de control automático de máquina-herramienta temprano. Sistemas de control numérico (NC) de lazo abierto guiaban un torno o fresadora siguiendo instrucciones codificadas como agujeros en cinta de papel. La máquina se movía ciegamente, siguiendo la cinta sin conciencia del estado de la pieza de trabajo.

Como el dispositivo era "ciego" a su entorno, no podía compensar cambios como expansión del metal o desgaste de herramienta. El programador también tenía que anticipar cada secuencia posible de instrucciones, ya que la cinta era solo-lectura y la máquina no tenía memoria interna para rastrear su estado.

Actualizar a una máquina de estados finitos (FSM) dio a la herramienta una memoria rudimentaria: al realimentar algunos bits de datos a la lógica de dirección, el sistema podía recordar estados simples como "refrigerante encendido" o "herramienta en posición". Sin embargo, esto aún quedaba corto de verdadera flexibilidad.

El avance llegó con control numérico de lazo cerrado (CNC), donde el programa podía escribir nuevos datos en memoria escribible (RAM). El sistema de control podía entonces registrar lo que había hecho y adaptarse a cambios detectados por sensores —muy como un maquinista anotando notas en un bloc para referencia posterior.

Científicos de computación han soñado largo tiempo con máquinas que puedan modificar su propio código, reflejando cómo el cerebro humano fortalece sinapsis através de experiencia. Para que tales programas auto-modificables sean factibles, el código ejecutable debe residir en la misma memoria escribible que almacena datos —una noción que permanece en la frontera de investigación hoy.

La mayoría del software sigue aún secuencias de instrucciones fijas, alterando solo un campo de datos separado. Para soportar verdaderamente el modelo de programa almacenado, necesitamos más que una FSM; necesitamos memoria lectura/escritura, una unidad de procesamiento de datos, y un controlador sofisticado.

Memoria lectura/escritura es provista fácilmente por chips RAM estática o dinámica —asequibles y rápidas. Operaciones lógicas son manejadas por una Unidad Aritmético-Lógica (ALU), que puede realizar funciones aritméticas y booleanas.

La Unidad de Control orquesta movimiento de datos entre memoria, ALU y dispositivos externos. Usa buffers tri-estado para enrutar datos en buses y lógica de decodificación para traducir códigos de instrucción binarios en acciones.

Instrucciones de ejemplo podrían ser: "Suma el valor en dirección 0010 al valor en dirección 1101", o "Calcula la paridad del byte en dirección 0111". El mapeo de códigos binarios a operaciones es arbitrario, muy como el estándar ASCII temprano, aunque los conjuntos de instrucciones son típicamente específicos de fabricante.

Cuando memoria lectura/escritura, una ALU y una Unidad de Control se integran —a menudo en un solo chip— forman un procesador. Un procesador con memoria externa mínima es un microprocesador; acoplado con circuitos de control de bus, se convierte en una Unidad Central de Procesamiento (CPU).

La operación de la CPU se encapsula en el ciclo fetch/ejecución. El contador de programa mantiene la dirección de la siguiente instrucción. La Unidad de Control lee esa dirección en el bus de direcciones de memoria, recupera la instrucción de RAM, y la almacena en un registro temporal.

Si la instrucción requiere operandos, la Unidad de Control emite accesos de memoria adicionales, enrutando los datos obtenidos a registros de la ALU. La ALU entonces realiza la operación solicitada, colocando el resultado en el acumulador. Finalmente, el contador de programa incrementa, y el ciclo se repite.

Microprocesador (CPU)

--------------------------------------
| ** Contador de programa ** |
| (incrementa valor dirección enviado a |
| chip(s) memoria externa para leer |==========> Bus de direcciones
| la siguiente instrucción) | (a memoria RAM)
--------------------------------------
| ** Unidad de Control ** |<=========> Bus de control
| (decodifica instrucciones leídas de | (a todos dispositivos compartiendo
| programa en memoria, habilita flujo | buses de direcciones y/o datos;
| de datos hacia y desde ALU, registros | arbitra todas las comunicaciones
| internos y dispositivos externos) | de bus)
--------------------------------------
| ** Unidad Aritmético-Lógica (ALU) ** |
| (realiza todos los cálculos | |
| matemáticos y funciones booleanas) | |
--------------------------------------
| ** Registros ** |
| (pequeñas memorias lectura/escritura para |<=========> Bus de datos
| guardar códigos instrucción, códigos error, | (de memoria RAM y otros
| datos ALU, etc; incluye el "acumulador") | dispositivos externos)
--------------------------------------

Incluso las operaciones más simples requieren muchos micro-pasos. Aritmética compleja como exponenciación involucra iteraciones repetidas de funciones básicas. Considere los miles de ciclos que el motor gráfico de un simulador de vuelo debe realizar para refrescar la pantalla cada frame.

La pura velocidad del ciclo fetch/ejecución hace esto factible. Algunos diseños embuten un pequeño programa —llamado microcódigo— en una ROM interna. El microcódigo maneja los sub-pasos de operaciones complejas, permitiendo al programador emitir una sola instrucción de alto nivel en lugar de escribir cada detalle.

De esta forma, un procesador contiene un procesador: un programa corriendo dentro de un programa que simplifica desarrollo mientras preserva rendimiento.