El esqueleto general de una computadora
En 1945, el matemático John von Neumann propuso un plano de arquitectura de computadoras que influye hasta el día de hoy.
La idea central de este plano es extremadamente simple, pero sentó las bases de todas las computadoras de propósito general de los últimos ochenta años.
Analogía cotidiana: el sistema de clasificación automática de una biblioteca
Imagina que entras en una gran biblioteca y quieres encontrar rápidamente un libro y enviarlo a un amigo lejano.
Debes seguir los siguientes pasos:
Primer paso: ingresar la solicitud— Escribes el título del libro en el terminal de la biblioteca.
Segundo paso: buscar la ubicación— El sistema consulta la base de datos según el título y encuentra en qué estante está el libro.
Tercer paso: sacar el libro— El brazo mecánico toma ese libro del estante.
Cuarto paso: empaquetar y enviar— Envuelves el libro, le pegas la etiqueta de envío y lo llevas a la oficina de correos.
Quinto paso: coordinar y dirigir— Todo esto requiere un sistema central de control para coordinar el orden y el ritmo.
Si traducimos este sistema a términos informáticos, corresponde a los cinco componentes principales de la arquitectura de Von Neumann:
| Analogía con la biblioteca | Componente de la computadora | Qué hace |
|---|---|---|
| Terminal de consulta | Dispositivo de entrada (Input) | Envía información externa a la computadora |
| Libros en el estante | Memoria (Memory) | Almacén que guarda programas y datos |
| Brazo mecánico | Unidad aritmético-lógica (ALU) | Ejecuta operaciones aritméticas y lógicas |
| Entrega de paquetes | Dispositivo de salida (Output) | Envía los resultados fuera de la computadora |
| Sistema central de control | Unidad de control (Control Unit) | Dirige los componentes para trabajar de manera coordinada |
¿Te has dado cuenta? La clave para que este sistema de la biblioteca funcione correctamente no está en cada componente en sí, sino en que hay un conjunto claro de reglas de flujo de datos entre ellos.
Del mismo modo, la esencia de la arquitectura de Von Neumann radica en«cómo se conectan y comunican los componentes»。
Principio central: la división del trabajo y la cooperación de los cinco componentes
Visión general de los cinco componentes
La arquitectura de Von Neumann divide una computadora en cinco partes funcionalmente independientes pero que colaboran estrechamente:
| Componente | Inglés | Interpretación sencilla | Función principal |
|---|---|---|---|
| Unidad aritmético-lógica | ALU (Arithmetic Logic Unit) | El «ábaco» de la computadora | Ejecuta operaciones aritméticas y lógicas como suma, resta, multiplicación, división, AND, OR, NOT, etc. |
| Unidad de control | Control Unit | El «centro de mando» de la computadora | Toma instrucciones de la memoria, las decodifica y emite señales de control para dirigir otros componentes |
| Memoria | Memory | El «almacén» de la computadora | Almacena instrucciones de programa y datos de operación; lee y escribe por dirección |
| Dispositivo de entrada | Input Devices | Los «ojos y oídos» de la computadora | Envía información externa (teclas, clics del ratón, datos de sensores) a la computadora |
| Dispositivo de salida | Output Devices | La «boca y las manos» de la computadora | Envía los resultados del cálculo en una forma perceptible para las personas (pantalla, impresión, sonido) |
La unidad aritmético-lógica y la unidad de control forman juntas lo que comúnmente llamamos CPU (Unidad Central de Procesamiento). Son el «cerebro» de la computadora, mientras que la memoria y los dispositivos de entrada/salida son el «sistema nervioso» y los «sentidos».
El siguiente diagrama de arquitectura utiliza rectángulos de cinco colores para representar los cinco componentes, y las líneas con flechas indican la dirección del flujo de datos.
La siguiente figura muestra la arquitectura de Von Neumann más clásica de las computadoras modernas. Todo el sistema consta de cinco partes: CPU, memoria (Memory), dispositivo de entrada (Input), dispositivo de salida (Output) e interfaz de E/S (I/O). Dentro de la CPU se incluyen la unidad de control (Control Unit), la unidad aritmético-lógica (ALU) y el conjunto de registros (Registers).
La CPU se comunica con la memoria y los dispositivos de E/S mediante el bus de datos (Data Bus), el bus de direcciones (Address Bus) y el bus de control (Control Bus): el bus de direcciones se encarga de especificar la posición de acceso; el bus de datos, de transmitir instrucciones y datos; y el bus de control, de enviar señales de control como lectura/escritura e interrupciones. Los tres realizan conjuntamente el intercambio de información dentro de la computadora.
Tres buses: la autopista de datos
Las conexiones entre los cinco componentes no son caóticas, sino que transmiten información de manera ordenada a través de tres grupos de «buses»:
| Tipo de bus | Inglés | Qué transmite | Dirección |
|---|---|---|---|
| Bus de datos | Data Bus | Instrucciones reales o datos de operación | Bidireccional (la CPU puede leer y escribir) |
| Bus de direcciones | Address Bus | La dirección de memoria a la que la CPU quiere acceder | Unidireccional (la CPU envía la dirección a la memoria) |
| Bus de control | Control Bus | Señales de control como habilitación de lectura/escritura, interrupciones, etc. | Las emite la unidad de control para dirigir los componentes |
Entender la diferencia entre estos tres buses es la clave para comprender la comunicación interna de la computadora. Puedes recordarlo así: el bus de direcciones dice «a dónde ir», el bus de datos se encarga de «llevar cosas» y el bus de control decide «qué acción hacer».
La idea del «programa almacenado»: el alma de la arquitectura de Von Neumann
La división en cinco componentes es solo el esqueleto externo; lo verdaderamente revolucionario de la arquitectura de Von Neumann radica en el«programa almacenado (Stored-Program)»concepto.
Antes de Von Neumann, para que una computadora ejecutara una tarea, había que conectar y desconectar cables manualmente, accionar interruptores e incluso cambiar placas de circuito.
Cambiar de tarea requería reajustar las conexiones físicas del hardware, como si antes de cada comida hubiera que volver a montar la cocina.
El avance de Von Neumann:
- El programa es un dato— Escribir los pasos de cálculo como una secuencia de instrucciones y colocarlos en la misma memoria que los datos.
- El software es modificable— Modificar un programa solo requiere modificar el contenido de las instrucciones en la memoria, sin necesidad de cambiar el hardware.
- Ejecución automática— La CPU automáticamente y en orden toma instrucciones de la memoria, las ejecuta y luego toma la siguiente.
Esta idea significa que la computadora pasó de ser una «herramienta de cálculo especializada» a ser una«plataforma de cálculo de propósito general».。
Demostración interactiva: explora los cinco componentes con el cursor (ejemplo)
Al pasar el cursor sobre cualquier componente en el diagrama de arquitectura de abajo, la tarjeta de explicación detallada correspondiente se resalta a la derecha.Haz clic en el botón «Ejecutar demostración»y observa un pequeño punto moviéndose a lo largo de las flechas de flujo de datos: simula la ruta completa de los datos desde el dispositivo de entrada hasta la memoria, entrando en la CPU para el cálculo, volviendo a la memoria y, finalmente, llegando al dispositivo de salida.
El «cerebro» de la computadora
Lee y escribe según la dirección
Los datos entran en la computadora
Los resultados salen de la computadora
Demostración interactiva: simula una computadora de programa almacenado mínima
El siguiente código Python simula una computadora minimalista de von Neumann: tiene una unidad aritmético-lógica (para sumar), una memoria (para almacenar instrucciones y datos), una unidad de control (que busca y ejecuta instrucciones secuencialmente según el puntero PC), y entrada/salida.
Lee atentamente los comentarios y luego ejecútalo.
Ejemplo
Simulador de computadora minimalista de von Neumann (demostración de ejemplo)
Muestra el trabajo coordinado de los cinco componentes principales: unidad aritmético-lógica, unidad de control, memoria, entrada y salida.
"""
class VonNeumannMachine:
"""Una versión condensada de una computadora con arquitectura de von Neumann"""
def __init__(self):
# --- Memoria (Memory) ---
# Un array unidimensional cuyas direcciones comienzan en 0, que almacena tanto instrucciones como datos.
self.memory = [0] * 256
# --- Unidad Aritmético-Lógica (ALU) + banco de registros ---
self.accumulator = 0 # Registro acumulador ACC, el registro central de la ALU.
self.temp = 0 # Registro temporal, utilizado para almacenar temporalmente el operando.
# --- Unidad de Control (Control Unit) ---
self.pc = 0 # Contador de programa PC, contiene la dirección de la siguiente instrucción.
self.running = True # Indicador de ejecución.
# --- Entrada / Salida ---
# Simula los datos enviados por el dispositivo de entrada.
self.input_buffer = []
# Simula los datos mostrados por el dispositivo de salida.
self.output_buffer = []
# ============================================================
# Dispositivo de entrada: escribe datos externos en una dirección de memoria específica.
# ============================================================
def input_to_memory(self, address, value):
print(f"[Dispositivo de entrada] Escribiendo datos en la dirección de memoria {address}: {value}")
self.memory[address] = value
# ============================================================
# Dispositivo de salida: lee y muestra datos desde una dirección de memoria específica.
# ============================================================
def output_from_memory(self, address):
val = self.memory[address]
print(f"[Dispositivo de salida] Leyendo datos de la dirección de memoria {address}: {val}")
self.output_buffer.append(val)
# ============================================================
# Memoria: operaciones de lectura / escritura (la CPU accede a través del bus)
# ============================================================
def mem_read(self, address):
"""Lee el contenido de la memoria desde una dirección específica"""
if 0 <= address < len(self.memory):
return self.memory[address]
raise ValueError(f"Dirección de memoria no válida: {address}")
def mem_write(self, address, value):
"""Escribe un valor en la memoria en una dirección específica"""
if 0 <= address < len(self.memory):
self.memory[address] = value
else:
raise ValueError(f"Dirección de memoria no válida: {address}")
# ============================================================
# Unidad Aritmético-Lógica (ALU): ejecuta operaciones aritméticas.
# ============================================================
def alu_add(self, operand):
"""Operación de suma de la ALU: ACC = ACC + operando"""
old_acc = self.accumulator
self.accumulator += operand
print(f"[Unidad ALU] Suma: {old_acc} + {operand} = {self.accumulator}")
def alu_load(self, operand):
"""Operación de carga de la ALU: carga un valor inmediato en ACC"""
self.accumulator = operand
print(f"[Unidad ALU] Carga: ACC = {operand}")
# ============================================================
# Unidad de control: búsqueda de instrucción, decodificación, despacho, actualización del PC.
# ============================================================
def fetch(self):
"""Fase de búsqueda de instrucción: obtiene la siguiente instrucción de la memoria según el PC"""
instruction = self.mem_read(self.pc)
print(f"\n"[Controlador FETCH] PC={self.pc}, código de instrucción obtenido: {instruction}")
self.pc += 1 # Después de la búsqueda, el PC se incrementa automáticamente en 1, apuntando a la siguiente instrucción.
return instruction
def decode_and_execute(self, instruction):
"""
Fase de decodificación + ejecución:
Definimos un conjunto de instrucciones minimalista (codificación mixta de código de operación + operando):
1 LOAD inmediato — Carga el valor de la siguiente celda de memoria en ACC
2 ADD dirección — Suma el valor de la dirección especificada a ACC
3 STORE dirección — Almacena el valor de ACC en la dirección especificada
255 HALT — Detener
"""
if instruction == 1: # LOAD
operand = self.mem_read(self.pc)
self.pc += 1
print(f"[Controlador DECODE] Instrucción: LOAD, operando: {operand}")
self.alu_load(operand)
elif instruction == 2: # ADD
address = self.mem_read(self.pc)
self.pc += 1
operand = self.mem_read(address)
print(f"[Controlador DECODE] Instrucción: ADD dirección[{address}] (valor: {operand})")
self.alu_add(operand)
elif instruction == 3: # STORE
address = self.mem_read(self.pc)
self.pc += 1
print(f"[Controlador DECODE] Instrucción: STORE dirección[{address}] (valor = {self.accumulator})")
self.mem_write(address, self.accumulator)
elif instruction == 255: # HALT
print(f"[Controlador DECODE] Instrucción: HALT (detenerse)")
self.running = False
else:
print(f"[Controlador] Instrucción desconocida: {instruction}, deteniéndose")
self.running = False
# ============================================================
# Ejecutar el programa completo
# ============================================================
def run(self):
"""Bucle principal: repetir búsqueda -> decodificación -> ejecución hasta detenerse"""
print("=" * 55)
print("Computadora minimalista de von Neumann iniciada")
print("=" * 55)
while self.running:
instr = self.fetch() # Buscar instrucción
self.decode_and_execute(instr) # Decodificar + ejecutar
print("\n" + "=" * 55)
print("Programa terminado, la computadora se detiene")
print("=" * 55)
# ================================================================
# Programa de ejemplo: calcula 10 + 20 y almacena el resultado en la dirección 100
# ================================================================
machine = VonNeumannMachine()
# El programa se escribe en la memoria (las instrucciones y los datos están mezclados; esto es lo que se llama "programa almacenado")
# Dirección 0: LOAD 10 (código de operación 1, operando 10)
# Dirección 2: ADD 100 (código de operación 2, operando 100; indica que el sumando se toma de la dirección 100)
# Dirección 4: STORE 200 (código de operación 3, operando 200; indica que el resultado se almacena en la dirección 200)
# Dirección 6: HALT (código de operación 255)
machine.memory[0] = 1
machine.memory[1] = 10 # Operando de LOAD: valor inmediato 10
machine.memory[2] = 2
machine.memory[3] = 100 # Operando de ADD: dirección 100 donde se encuentra el dato
machine.memory[4] = 3
machine.memory[5] = 200 # Operando de STORE: dirección 200 donde se almacenará el resultado
machine.memory[6] = 255 # HALT
# Almacenar el sumando 20 en la dirección 100 (simula la escritura de datos por el dispositivo de entrada)
machine.input_to_memory(100, 20)
# Ejecutar el programa
machine.run()
# Ver el resultado
result = machine.mem_read(200)
print(f"\n"Resultado final: valor en la dirección de memoria 200 = {result}")
machine.output_from_memory(200)
print(f"Buffer del dispositivo de salida: {machine.output_buffer}")
Al ejecutar este programa, verás cómo las instrucciones se van buscando, decodificando y ejecutando una a una. Esto es lo que ocurre cientos de millones de veces por segundo en tu computadora; solo que el conjunto de instrucciones de una CPU real es mucho más complejo.
Resumen y verificación
Resumen en una frase
La arquitectura de von Neumann divide la computadora en cinco partes: unidad aritmético-lógica, unidad de control, memoria, dispositivo de entrada y dispositivo de salida, conectadas mediante tres conjuntos de buses. Además, almacena programas y datos en la misma memoria, y la CPU busca y ejecuta automáticamente las instrucciones en orden.
Autoevaluación
Pregunta 1De los cinco componentes de la arquitectura de von Neumann, ¿qué dos componentes se conocen conjuntamente como CPU?
- A. Unidad aritmético-lógica y memoria
- B. Unidad aritmético-lógica y unidad de control
- C. Unidad de control y memoria
- D. Dispositivo de entrada y dispositivo de salida
Respuesta correcta: B
Pregunta 2¿Cuál es la función del bus de direcciones? ¿Cuál es la dirección de transferencia de datos?
- A. Transmitir resultados de operaciones; bidireccional
- B. Transmitir señales de control; emitidas por la unidad de control
- C. Transmitir direcciones de memoria; de la CPU a la memoria (unidireccional)
- D. Transmitir instrucciones y datos; bidireccional
Respuesta correcta: C. El bus de direcciones envía información de direcciones desde la CPU a la memoria; es unidireccional.
Pregunta 3¿Cuál es la importancia central de la idea del "programa almacenado"?
- A. La computadora ya no necesita unidad aritmético-lógica
- B. Modificar el software solo requiere cambiar el contenido de la memoria, sin necesidad de modificar el hardware
- C. La capacidad de la memoria es mayor que la de la CPU
- D. Los dispositivos de entrada y salida pueden combinarse
Respuesta correcta: B. El programa almacenado convierte a la computadora de un dispositivo especializado en una plataforma de propósito general, donde el software se puede cambiar con flexibilidad.
Otras extensiones