¿Por qué los programas y los datos pueden estar en la misma memoria?

En la lección anterior vimos el panorama completo de la arquitectura de von Neumann: cinco componentes principales y tres buses.

En esta lección nos centramos en su idea más revolucionaria:Tratar las instrucciones de programa como un tipo especial de dato y almacenarlas junto con los datos en la misma memoria.。


Analogía cotidiana: la partitura y el reproductor de música

Imagina dos dispositivos de música diferentes:

Dispositivo A: la caja de música

Una caja de música de cuerda que tiene en su interior un cilindro metálico lleno de púas. Cada púa pulsa una lengüeta de acero para producir una nota.

¿Quieres cambiar de canción? Tienes que desmontar la caja de música y poner otro cilindro con una disposición de púas diferente. El cilindro en sí mismo es la fusión física del «programa» y el «reproductor».

Dispositivo B: la app de música en un teléfono inteligente

Tu teléfono tiene almacenados cientos de archivos MP3. Toca cualquiera y se reproduce.

Los archivos MP3 (programa/datos) y la app reproductora (ejecutor) están separados: para cambiar de canción solo hay que cambiar el archivo, no el teléfono.

La caja de música es la computadora anterior a von Neumann: el programa y el hardware están ligados; cambiar de tarea equivale a cambiar de máquina.

El teléfono inteligente es la computadora posterior a von Neumann: el programa es contenido reemplazable en el almacenamiento, y el hardware es una plataforma de ejecución de propósito general.

Dimensión de comparaciónCaja de música (control por programa externo)Teléfono inteligente (programa almacenado)
Método de almacenamiento del programaFijado en la estructura mecánicaExiste en la memoria como datos
Cambiar de canciónDesmontar y cambiar el cilindroBasta con tocar la pantalla
¿Es el hardware de propósito general?Una caja de música = una canciónUn teléfono = infinitas canciones
FlexibilidadCasi nulaMuy alta

Lo que hizo von Neumann fue exactamente esto: extraer la «partitura» del hardware y convertirla en un «archivo de datos» que puede reemplazarse libremente. A partir de entonces, el hardware es hardware y el software es software.


Contexto histórico: del «control por programa externo» al «programa almacenado»

2.1 Las computadoras anteriores a von Neumann

A principios de la década de 1940, ya había algunas computadoras electrónicas en uso, pero todas tenían un problema común:

ENIAC (1946)— la primera computadora electrónica de propósito general del mundo, con una velocidad de cálculo asombrosa, pero cada vez que se cambiaba de tarea de cálculo, los ingenieros necesitaban varios díaspara conectar y desconectar manualmente cientos de cables y ajustar miles de interruptorescon el fin de «reprogramarla».

Harvard Mark I (1944)— usaba cintas de papel perforado para ingresar el programa, pero la memoria de programa (el lector de cintas) y la memoria de datos eran dos dispositivos físicamente separados; la CPU no podía acceder a las instrucciones del programa de la misma manera que accedía a los datos.

Las desventajas comunes de estas máquinas:

  • Cambiar el programa era extremadamente lento: requería ajustar manualmente las conexiones de hardware o reemplazar el soporte físico.
  • Las instrucciones del programa no podían ser modificadas por el propio programa, lo que limitaba la aparición de técnicas de programación avanzadas (como compiladores y enlazadores).
  • El diseño del hardware era complejo: cada tipo de tarea podía requerir una configuración de hardware diferente.

2.2 El avance de von Neumann

En 1945, von Neumann propuso una idea audaz en el «Primer borrador de un informe sobre el EDVAC»:

Codificar las instrucciones del programa como números binarios y almacenarlas junto con los datos en una misma memoria direccionable.

Esta idea aportó tres ventajas decisivas:

  1. Unificación del hardware: la CPU no necesita saber si una ubicación de memoria contiene una instrucción o un dato; solo se limita a leer y escribir según la dirección. Esto simplificó enormemente el diseño del hardware.
  2. Existencia independiente del software: el programa se convirtió en un «archivo» que puede almacenarse, copiarse y transmitirse. Así nació el concepto de «software».
  3. El programa puede modificarse a sí mismo: el programa puede modificar sus propias instrucciones o las de otros programas como si manipulara datos. Esto sentó las bases para tecnologías trascendentales como el ensamblador, el compilador y el sistema operativo.

Explicación del principio: coexistencia de instrucciones y datos en la memoria

3.1 Diagrama de la memoria: ¿cuál es la instrucción? ¿cuál es el dato?

La siguiente imagen muestra una instantánea de una región de memoria. Cada celda es una unidad de almacenamiento con una dirección única.

Observa:Las instrucciones y los datos son físicamente idénticos: todos son 0 y 1.La única forma de distinguirlos es quién los accede y en qué momento.

Degradado de color para instrucciones Degradado de color para datos Fondo de la memoria Memoria principal (RAM) Encabezado de la tabla Dirección Contenido almacenado Tipo Significado real Fila de datos Dirección 0: instrucción LOAD A 5 0x0000 10110001 00000101 [Instrucción] LOAD A, 5 Dirección 2: dato 5 (valor de A) 0x0001 00000000 00000101 [Dato] Valor inmediato 5 Dirección 3: instrucción LOAD B 3 0x0002 10110010 00000011 [Instrucción] LOAD B, 3 Dirección 5: dato 3 (valor de B) 0x0003 00000000 00000011 [Dato] Valor inmediato 3 Dirección 4: instrucción ADD A B 0x0004 00100000 00000001 [Instrucción] ADD A, B Dirección 6: instrucción STORE A 0x0005 00110000 01100100 [Instrucción] STORE 100 Dirección 100: dato (resultado almacenado) 0x0064 00000000 00001000 [Dato] Resultado del cálculo: 8 Área de leyenda Leyenda: Resaltado azul = unidad de instrucción (código de operación + operando) Resaltado naranja = unidad de datos (valor inmediato, valor de variable, resultado de cálculo) Nota: las instrucciones y los datos son idénticos en el almacenamiento físico; todos son bits. Solo el puntero PC de la CPU, cuando busca una instrucción, determina si es una instrucción o un dato.

3.2 Pregunta clave: ¿cómo distingue la CPU entre instrucciones y datos?

Del diagrama anterior se desprende un hecho clave: a nivel de almacenamiento físico, las instrucciones y los datosson completamente indistinguibles— ambos son cadenas de bits.

Entonces, ¿cómo sabe la CPU si debe tratar una celda de memoria como instrucción o como dato?

La respuesta es sencilla:Depende del momento del acceso y de quién accede.

  • Fase de búsqueda de instrucción (fetch): de la CPUcontador de programa (PC)proporciona la dirección, y el controlador emite la señal de control «leer instrucción». En ese momento, el contenido leído de la memoria se trata como una «instrucción» y se envía al registro de instrucción para decodificarla.
  • Fase de ejecución: la CPU calcula la dirección del operando según el resultado de la decodificación (puede provenir de un registro o de un valor inmediato de la instrucción), y el controlador emite la señal de control «leer dato». En ese momento, el contenido leído de la memoria se trata como un «dato» y se envía a la ALU para participar en la operación.

Resumen en una frase: para una misma dirección de memoria, cuando el PC apunta a ella es una «instrucción»; cuando una dirección de operando apunta a ella, es un «dato». Esa es la esencia del «programa almacenado»: las instrucciones y los datos son físicamente indistinguibles, y lógicamente se distinguen por el contexto de acceso.


Demostración interactiva: explora por ti mismo las instrucciones y los datos en la memoria

El siguiente código Python crea un sistema de memoria que puedes explorar interactivamente: puedes escribir instrucciones o datos, luego ver el contenido de cualquier dirección de memoria y determinar si es una instrucción o un dato.

Ejemplo

"""
Demostración de almacenamiento mixto de instrucciones y datos en memoria (demostración de ejemplo)
Muestra la idea del «programa almacenado»: las instrucciones y los datos en la misma memoria no pueden distinguirse por su contenido almacenado.
"""


class MemoryInspector:
    """Inspector de memoria: muestra visualmente la coexistencia de instrucciones y datos en la memoria"""

    def __init__(self, size=256):
        # Inicializar memoria: cada celda almacena un valor entero (simulando 8 bits)
        self.memory = [0] * size
        # Matriz de marcas: registra el tipo de cada dirección: 'instruction' o 'data'
        # Nota: ¡en el hardware real no existe esta marca! Aquí es solo para facilitar la demostración
        self.type_tags = ['empty'] * size
        # Registrar la explicación mnemónica de cada dirección (también para facilitar la demostración)
        self.annotations = [''] * size

    def write_instruction(self, address, opcode, operand, annotation=""):
        """Escribir una instrucción en la memoria (ocupa dos celdas: código de operación + operando)"""
        self.memory[address] = opcode
        self.type_tags[address] = 'instruction'
        self.annotations[address] = annotation

        self.memory[address + 1] = operand
        self.type_tags[address + 1] = 'instruction'
        self.annotations[address + 1] = f" └ Operando: {operand}"

    def write_data(self, address, value, annotation=""):
        """Escribir una unidad de datos en la memoria"""
        self.memory[address] = value
        self.type_tags[address] = 'data'
        self.annotations[address] = annotation

    def inspect(self, start=0, end=16):
        """Ver el contenido de memoria de un rango específico"""
        print("=" * 68)
        print(f"{'Dirección':>6} | {'Valor almacenado':>8} | {'Binario':>10} | {'Tipo':>12} | Significado")
        print("-" * 68)
        for addr in range(start, min(end, len(self.memory))):
            val = self.memory[addr]
            binary = format(val, '08b')  # Representación binaria de 8 bits
            tag = self.type_tags[addr]
            anno = self.annotations[addr]

            } (código de operación)"
            marker = "[I]" if tag == 'instruction' else \
                     "[D]" if tag == 'data' else \
                     "[ ]"

            if val != 0 or tag != 'empty':
                print(f"  {addr:4d} | {marker} {val:5d} |  {binary}  | {tag:>12} | {anno}")

        print("=" * 68)
        print(} (el operando ha cambiado)"\n")

    def compare_bytes(self, addr1, addr2):
        """
Compara los bytes brutos de dos direcciones: descubrirás que no se pueden distinguir a nivel binario.
        """

        v1 = self.memory[addr1]
        v2 = self.memory[addr2]
        b1 = format(v1, '08b')
        b2 = format(v2, '08b')

        print(f"\n"--- Comparando dirección {addr1} y dirección {addr2} ---")
        print(f"Dirección {addr1}: binario {b1} (tipo: {self.type_tags[addr1]})")
        print(f"Dirección {addr2}: binario {b2} (tipo: {self.type_tags[addr2]})")
        if b1 == b2 and self.type_tags[addr1] != self.type_tags[addr2]:
            print(f">>> Hallazgo clave: ¡el contenido binario de estas dos direcciones es exactamente el mismo ({b1})!")
            print(f">>> Pero sus tipos son diferentes: la dirección {addr1} es {self.type_tags[addr1]},")
            print(f">>> la dirección {addr2} es {self.type_tags[addr2]}.")
            print(f">>> Esto demuestra que, solo con el contenido binario, no se pueden distinguir instrucciones y datos.")
        else:
            print(f"El contenido de estas dos direcciones es diferente.")

    def simulate_instruction_data_ambiguity(self, addr):
        """
Demostrar que el mismo valor binario se interpreta con diferentes significados en diferentes contextos.
        """

        val = self.memory[addr]
        binary = format(val, '08b')
        print(f"\n"--- Demostración de la ambigüedad de la dirección {addr} ---")
        print(f"Valor binario almacenado: {binary} (decimal: {val})")
        print(f"")
        print(f"Si el PC de la CPU apunta aquí (fase de búsqueda de instrucción):")
        print(f" -> Este byte se interpreta como «código de operación de instrucción»")
        print(f" -> Por ejemplo, {binary} podría representar la instrucción 'LOAD'")
        print(f"")
        print(f"Si la ALU hace referencia a esto mediante la dirección del operando (fase de ejecución):")
        print(f" -> Este byte se interpreta como «dato»")
        print(f" -> Por ejemplo, el decimal {val} es simplemente un valor numérico ordinario")
        print(f"")
        print(f"¡La misma secuencia de bits, leída por diferentes roles, tiene significados completamente diferentes!")


# ================================================================
# Demostración 1: construir almacenamiento mixto en memoria
# ================================================================
print(">>> Demostración 1: almacenar instrucciones y datos de forma mixta en la memoria"\n")
mem = MemoryInspector()

# Escribir secuencia de instrucciones
mem.write_instruction(0, 0xB1, 5, "LOAD A, 5")
mem.write_instruction(2, 0xB2, 3, "LOAD B, 3")
mem.write_instruction(4, 0x20, 1, "ADD A, B")
mem.write_instruction(6, 0x30, 100, "STORE 100")

# Escribir datos
mem.write_data(100, 8, "Resultado del cálculo: 5 + 3 = 8")

# Ver el panorama de la memoria
mem.inspect(0, 8)
mem.inspect(100, 102)

# ================================================================
# Demostración 2: ambigüedad instrucción/dato del mismo valor
# ================================================================
print(">>> Demostración 2: el mismo valor binario puede ser una instrucción o un dato"\n")

# Escribir intencionalmente un valor 5 en la dirección (área de instrucciones) y también un 5 en la dirección 200 (área de datos)
mem.write_instruction(10, 5, 0, "Este 5 es un código de operación")
mem.write_data(200, 5, "Este 5 es un valor de dato")

mem.compare_bytes(10, 200)

# Demostración de ambigüedad
mem.simulate_instruction_data_ambiguity(10)

# ================================================================
# Demostración 3: concepto de código automodificable (tema avanzado)
# ================================================================
print(">>> Demostración 3: concepto de modificación del programa sobre sí mismo"\n")
print("¡Debido a que las instrucciones y los datos están en la misma memoria, un programa puede modificar sus propias instrucciones!")
print("Esta es precisamente la capacidad que aporta la arquitectura de programa almacenado.")
print("")
print("Por ejemplo, el programa puede cambiar la instrucción STORE 100 en la dirección 6 a STORE 200:")
print(f"Antes de modificar dirección 6: {mem.memory)
print(f"Antes de modificar dirección 7: {mem.memory)

# El programa se modifica a sí mismo: cambiar el operando de STORE de 100 a 200
mem.memory[7] = 200
mem.type_tags[7] = 'data'
mem.annotations[7] = "Modificado por el propio programa: operando 100 -> 200"

print(f"Después de modificar dirección 7: {mem.memory)
print("")
mem.inspect(6, 8)
print(">>> Esta capacidad es la base de tecnologías como compiladores, enlazadores dinámicos y máquinas virtuales.")

Al ejecutar este programa verás claramente que las instrucciones y los datos son diferentes «roles» dentro de la misma memoria. Comparten el mismo mecanismo de almacenamiento y direccionamiento: esta es la esencia más profunda de la arquitectura de von Neumann.

3.3 Demostración interactiva: haz clic en las celdas de memoria para ver el contenido (ejemplo)

A continuación se muestra una simulación de un área de memoria de 64 bytes.Las celdas azules representan instrucciones,Las celdas naranjas representan datoslas grises son áreas libres. Pasa el cursor sobre cualquier celda para ver el valor original almacenado,Haz clic en una celdaVer la explicación detallada, incluyendo si esa dirección almacena una «instrucción» o un «dato», y su significado real.

Instrucción (Instruction) Dato (Data) Libre (Empty)
Las celdas se generan dinámicamente con JS
Haz clic en las celdas de memoria de arriba para ver el tipo y el significado del contenido almacenado en esa dirección.

Comparación con la arquitectura Harvard

La arquitectura de von Neumann no es la única arquitectura de computadoras. Su principal «competidora» esArquitectura Harvard (Harvard Architecture)。

Dimensión de comparaciónArquitectura de von NeumannArquitectura Harvard
MemoriaAlmacenamiento único, compartida por instrucciones y datosDos memorias independientes, instrucciones y datos separados
BusUn conjunto de buses de dirección/datos, instrucciones y datos comparten el bus por división de tiempoDos conjuntos de buses independientes, pueden acceder simultáneamente a instrucciones y datos
VentajasDiseño de hardware simple, alta utilización de memoria, software flexiblePuede obtener instrucciones y datos al mismo tiempo, más rápido (amigable para el pipeline)
DesventajasLa obtención de instrucciones y datos puede entrar en conflicto (cuello de botella de von Neumann)Hardware más complejo, el almacenamiento de instrucciones y datos no se puede asignar dinámicamente
Aplicaciones típicasComputadoras de propósito general como PC y servidoresMCU embebidos, procesadores de señal digital DSP

Los CPU modernos suelen fusionar ambas arquitecturas en su implementación real: hacia el exterior presentan el modelo de memoria unificado de la arquitectura de von Neumann (para facilitar la programación), y en el interior, a nivel de caché L1, usan cachés separadas de instrucciones y de datos (aprovechando la ventaja de velocidad de la arquitectura Harvard). Esto es lo que se llama «arquitectura Harvard modificada».

Otras extensiones