El viaje completo de una instrucción

Desde los fundamentos binarios de la primera lección hasta el sistema de E/S de la lección anterior, ya hemos cubierto todo el contenido central de los principios de organización de computadoras. En esta lección, vamos a conectar estos puntos de conocimiento en una línea y a seguir el viaje completo de una instrucción, desde que nace hasta que se completa.

Implementaremos un completoSimulador de computadora Von Neumann (FullComputer), que incluye: estructura de almacenamiento de cuatro niveles (disco duro, memoria, caché, registros), transmisión de datos por DMA, pipeline de cuatro etapas (fetch-decode-execute-writeback), interacción por bus y estadísticas de tasa de aciertos de caché. Finalmente, imprime un informe de ejecución completo.


Repaso: mapa de conocimientos de los seis módulos

Antes de comenzar la simulación de extremo a extremo (end-to-end), repasemos rápidamente los conceptos centrales de cada uno de los seis módulos del curso:

MóduloTemaConceptos centralesReflejo en esta lección
Primer móduloBinario y representación de la informaciónCodificación 0/1, conversión de bases, complemento a dos, números de punto flotanteLas instrucciones y los datos se almacenan en la memoria en forma binaria
Segundo móduloPuertas lógicas y circuitos digitalesPuertas AND, OR, NOT, sumador, ALULas operaciones de la ALU en la fase de ejecución se implementan mediante circuitos de puertas
Tercer móduloArquitectura de Von NeumannCinco componentes principales, programa almacenado, ciclo de instrucciónLo que se simula en esta lección es una máquina Von Neumann completa
Cuarto móduloPrincipios de la CPURegistros, PC, IR, pipeline, cuatro etapasSimulación completa de las cuatro etapas: fetch, decode, execute, writeback
Quinto móduloSistema de almacenamientoJerarquía de memoria, caché, principio de localidadDisco duro → memoria → caché → registros, la cadena completa de los cuatro niveles de almacenamiento
Sexto móduloBus y E/SBus de direcciones/datos/control, sondeo/interrupción/DMADMA carga programas, bus transmite datos, llenado de líneas de caché

El ciclo de vida completo de una instrucción

Tomamos una pseudoinstrucción simpleADD A, B(suma los valores de los registros A y B, y almacena el resultado en A) como ejemplo para seguir su viaje completo:

Paso uno del viaje: el programa se almacena en el disco duro

El programa se guarda inicialmente en el disco duro como archivo. El disco duro es unalmacenamiento persistente, los datos no se pierden al apagar, pero la velocidad de lectura/escritura es la más lenta (milisegundos).

Paso dos del viaje: la DMA carga el programa en la memoria

Cuando haces doble clic para ejecutar el programa, el sistema operativoDMAmueve el programa del disco duro a la memoria. El controlador DMA se hace cargo del trabajo de transferencia de datos, y durante este tiempo la CPU puede hacer otras cosas.

Paso tres del viaje: la CPU obtiene la instrucción a través del bus

La CPU coloca el valor del contador de programa (PC) en elbus de direccionesy, en elbus de controlemite la señal de «lectura». Cuando la memoria recibe la señal, coloca la instrucción de la dirección correspondiente en elbus de datosy la CPU la lee en el registro de instrucción (IR).

Paso cuatro del viaje: decodificación — el controlador analiza la instrucción

La instrucción ADD A, B en el registro de instrucción se descompone en tres partes: el código de operación ADD, el operando destino A y el operando fuente B. El controlador decide la siguiente operación según el código de operación.

Paso cinco del viaje: ejecución — la ALU realiza la operación

El controlador emite señales de control para que la ALU tome los valores de los registros A y B, ejecute la suma y almacene temporalmente el resultado en la salida de la ALU.

Paso seis del viaje: escritura de retorno — el resultado se guarda en el registro a través del bus de datos

El resultado del cálculo de la ALU se transfiere a través delbus de datosy se escribe de vuelta en el registro A. Con esto, una instrucción ha terminado de ejecutarse. El PC se incrementa automáticamente en 1 y apunta a la siguiente instrucción.


Demostración de código: simulación completa de FullComputer

La siguiente clase FullComputer simula por completo todo el proceso anterior. Contiene más de 300 líneas de código y cubre los conceptos de los seis módulos del curso. Cada paso imprime un registro detallado.

Ejemplo

"""
FullComputer - Simulador completo de computadora Von Neumann (demostración educativa de ejemplo)

Este programa implementa una computadora Von Neumann completa (versión simplificada), que incluye:
- Almacenamiento en cuatro niveles: Disco (Disk) → Memoria (Memory) → Caché (Cache) → Registro (Register)
- Controlador DMA: mueve automáticamente el programa del disco duro a la memoria
- Tres tipos de bus: bus de direcciones, bus de datos, bus de control
- Ejecución en cuatro etapas: Fetch (captación) → Decode (decodificación) → Execute (ejecución) → WriteBack (escritura de retorno)
- Sistema de estadísticas: tasa de aciertos de caché, contador de instrucciones, número de usos del bus, tiempo de ejecución

Conjunto de instrucciones soportado:
LOAD reg value - Carga un valor inmediato en el registro
STORE reg addr - Almacena el valor del registro en la dirección de memoria
  ADD dst src      - dst = dst + src
  SUB dst src      - dst = dst - src
  MUL dst src      - dst = dst * src
CMP a b - Compara dos registros y establece los indicadores (flags)
JMP addr - Salto incondicional
JZ addr - Salta si el indicador de cero es verdadero

Forma de ejecución: python fullcomputer.py
"""


import time


# ============================
# 1. Sistema de almacenamiento: estructura de cuatro niveles
# ============================

class Disk:
    """
Disco duro: el almacenamiento persistente de nivel más bajo.
Velocidad más lenta (milisegundos), mayor capacidad y los datos no se pierden al apagar.
    """

    def __init__(self):
        self.sectors = {}          # Almacenamiento por sectores, simula los sectores del disco duro
        self.read_latency = 5      # Latencia de lectura (unidad de tiempo simulada)
        self.write_latency = 8     # Latencia de escritura

    def load_program(self, program_name):
        """Carga el programa almacenado en el disco duro. Devuelve None si el programa no existe."""
        if program_name in self.sectors:
            print(f" [Disco] Programa '{program_name}' encontrado, tamaño: {len(self.sectors[program_name])} instrucciones")
            return self.sectors[program_name]
        print(f" [Disco] ¡Programa '{program_name}' no encontrado!")
        return None

    def store_program(self, name, program):
        """Almacena el programa en el disco duro."""
        self.sectors[name] = program
        print(f" [Disco] Programa '{name}' almacenado ({len(program)} instrucciones) en el sector 0x{hash(name) & 0xFFFF:04X}")


class Memory:
    """
Memoria principal: segundo nivel de almacenamiento.
Velocidad media (nanosegundos), capacidad mayor, los datos se pierden al apagar.
La CPU solo puede acceder directamente a los datos en la memoria (no puede acceder directamente al disco duro).
    """

    def __init__(self, size=65536):
        self.size = size           # Tamaño de la memoria (bytes)
        self.cells = {}            # Celdas de memoria: clave es la dirección, valor es el dato/instrucción
        self.read_count = 0        # Contador de operaciones de lectura
        self.write_count = 0       # Contador de operaciones de escritura

    def read(self, addr):
        """Lee datos de la dirección especificada."""
        self.read_count += 1
        if addr not in self.cells:
            print(f" Advertencia: la dirección {addr} no está inicializada, se devuelve 0")
            return 0
        return self.cells[addr]

    def write(self, addr, data):
        """Escribe datos en la dirección especificada."""
        self.write_count += 1
        self.cells[addr] = data

    def load_block(self, start_addr, data_block):
        """
Carga un bloque completo de datos en un área de direcciones contiguas de la memoria.
Se utiliza en escenarios de transferencia por lotes mediante DMA.
        """

        for i, item in enumerate(data_block):
            self.cells[start_addr + i] = item
        return len(data_block)


class Cache:
    """
Caché (simulación de caché L1): tercer nivel de almacenamiento.
Velocidad muy alta (a la misma frecuencia que la CPU), capacidad mínima.

Utiliza un modelo de caché de asignación directa simple:
- Cada línea de caché almacena: (dirección de memoria, contenido del dato)
- Acierto de caché: si el dato ya está en la caché, se devuelve directamente
- Fallo de caché: es necesario cargar desde la memoria y reemplazar una línea de caché
    """

    def __init__(self, num_lines=8):
        self.num_lines = num_lines
        self.lines = {}            # Línea de caché: {cache_line_index: (mem_addr, data)}
        self.hit_count = 0
        self.miss_count = 0

    def read(self, mem_addr, memory):
        """
Leer desde la caché. Si hay acierto, devolver directamente; si hay fallo, cargar desde la memoria.
Devuelve: (data, was_hit)
        """

        # Mapeo simple: índice de línea de caché = dirección de memoria % número de líneas de caché
        line_index = mem_addr % self.num_lines

        if line_index in self.lines:
            cached_addr, cached_data = self.lines[line_index]
            if cached_addr == mem_addr:
                # Acierto de caché
                self.hit_count += 1
                print(f" [Caché] ¡Acierto! Línea {line_index}, dirección {mem_addr}, datos: {cached_data}")
                return cached_data, True

        # Fallo de caché
        self.miss_count += 1
        data = memory.read(mem_addr)
        self.lines[line_index] = (mem_addr, data)
        print(f" [Caché] Fallo, cargando datos {data} desde la dirección de memoria {mem_addr} → línea de caché {line_index}")
        return data, False

    @property
    def hit_rate(self):
        total = self.hit_count + self.miss_count
        return self.hit_count / total * 100 if total > 0 else 0.0


class RegisterFile:
    """
Conjunto de registros: el almacenamiento de nivel más alto.
El más rápido (un ciclo de reloj), la menor capacidad.
Registros de propósito general + registros especiales (PC, IR, MAR, MDR, FLAGS)
    """

    def __init__(self):
        # Registros de propósito general
        self.gpr = {'A': 0, 'B': 0, 'C': 0, 'D': 0}

        # Registros especiales
        self.PC = 0                # Contador de programa: almacena la dirección de la siguiente instrucción
        self.IR = None             # Registro de instrucción: almacena la instrucción que se está ejecutando actualmente
        self.MAR = 0               # Registro de dirección de memoria: almacena la dirección de memoria a acceder
        self.MDR = 0               # Registro de datos de memoria: almacena los datos leídos de / que se escribirán en la memoria

        # Registro de banderas
        self.FLAGS = {'Z': False}  # Banderas de cero: si el resultado de la última operación es 0

    def __repr__(self):
        gpr_str = ', '.join(f'{k}={v}' for k, v in self.gpr.items())
        return f"GPR[{gpr_str}] PC={self.PC} IR={self.IR} FLAGS={self.FLAGS}"


# ============================
# 2. Sistema de buses: tres buses
# ============================

class SystemBus:
    """
Bus del sistema: incluye bus de direcciones, bus de datos y bus de control.
Proporciona una interfaz unificada para que la CPU, la memoria y el DMA la usen.
    """

    def __init__(self):
        self.address_bus = 0       # Bus de direcciones: dirección transmitida actualmente
        self.data_bus = 0          # Bus de datos: datos transmitidos actualmente
        self.control_bus = 'IDLE'  # Bus de control: IDLE, READ, WRITE, INTERRUPT, DMA_REQ, DMA_ACK
        self.transfer_count = 0    # Contador de transferencias del bus

    def cpu_read(self, address, memory, cache):
        """
La CPU lee datos de la memoria a través del bus (pasando por la caché).
Proceso completo de interacción del bus:
1. La CPU coloca la dirección en el bus de direcciones
2. La CPU emite la señal READ en el bus de control
3. La memoria (a través de la capa de caché) devuelve los datos al bus de datos
4. La CPU lee los datos del bus de datos
5. El bus se limpia
        """

        self.address_bus = address
        self.control_bus = 'READ'
        self.transfer_count += 1
        print(f" [Bus] Bus de direcciones ← {address}, bus de control ← READ")

        # La memoria responde a través de la capa de caché
        data, was_hit = cache.read(address, memory)
        self.data_bus = data
        print(f" [Bus] Bus de datos ← {data} {'(acierto de caché)' if was_hit else '(desde memoria)'}")

        # La CPU lee los datos
        result = self.data_bus

        # El bus se limpia
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f" [Bus] Bus limpiado, entrando en estado inactivo")

        return result

    def cpu_write(self, address, data, memory):
        """
La CPU escribe datos en la memoria a través del bus.
        """

        self.address_bus = address
        self.data_bus = data
        self.control_bus = 'WRITE'
        self.transfer_count += 1
        print(f" [Bus] Bus de direcciones ← {address}, bus de datos ← {data}, bus de control ← WRITE")

        memory.write(address, data)
        print(f" [Bus] Los datos {data} se han escrito en la dirección de memoria {address}")

        # El bus se limpia
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f" [Bus] Bus limpiado, entrando en estado inactivo")


# ============================
# 3. Controlador DMA
# ============================

class DMAController:
    """
Controlador DMA: responsable de transferir datos directamente entre el disco duro y la memoria.
La CPU solo necesita decirle al DMA: dirección de origen, dirección de destino, longitud de la transferencia.
El DMA notifica a la CPU mediante una interrupción después de completar la transferencia.
    """

    def __init__(self, bus):
        self.bus = bus
        self.transfer_count = 0    # Contador del número de transferencias DMA
        self.total_bytes = 0       # Número total de bytes transferidos

    def transfer_program(self, disk, program_name, memory, load_addr=0):
        """
Cargar el programa desde el disco duro a la memoria mediante DMA.
Esta es la aplicación práctica de la lección 20 del curso «Modo DMA».
        """

        print(f"\n  {'='*50}")
        print(f" Transferencia DMA iniciada: disco duro → memoria")
        print(f"  {'='*50}")
        print(f" [DMA] Origen: sector del disco duro (programa '{program_name}')")
        print(f" [DMA] Destino: comienza en la dirección de memoria 0x{load_addr:04X}")
        print(f" [DMA] Solicitando control del bus...")

        # El DMA ocupa el bus
        self.bus.control_bus = 'DMA_REQ'
        print(f" [DMA] Control del bus obtenido (bus de control ← DMA_REQ)")

        program = disk.load_program(program_name)
        if program is None:
            print(f" [DMA] Error: el programa no existe, transferencia abortada")
            self.bus.control_bus = 'IDLE'
            return 0

        # Transferir instrucción por instrucción
        for i, instruction in enumerate(program):
            addr = load_addr + i
            memory.write(addr, instruction)
            self.bus.address_bus = addr
            self.bus.data_bus = instruction
            self.total_bytes += 1
            self.transfer_count += 1
            print(f" [DMA] Transferencia #{i}: instrucción '{instruction}' → dirección de memoria {addr} (0x{addr:04X})")

        # El DMA libera el bus y envía la interrupción de finalización
        self.bus.control_bus = 'DMA_ACK'
        print(f" [DMA] ¡Transferencia completada! {len(program)} instrucciones, {self.total_bytes} transferencias de bus")
        print(f" [DMA] Liberando el control del bus (bus de control ← IDLE)")

        # Interrupción para notificar a la CPU
        print(f" [DMA] Enviando señal de interrupción a la CPU: programa cargado")
        self.bus.control_bus = 'INTERRUPT'

        # Procesamiento después de que la CPU recibe la interrupción
        time.sleep(0.001)
        print(f" [Respuesta a interrupción de CPU] Interrupción de finalización de DMA recibida, programa listo")
        self.bus.control_bus = 'IDLE'

        return len(program)

    def cache_prefetch(self, memory, cache, start_addr, count):
        """
Prefetch DMA: cargar anticipadamente en la caché los datos que se usarán próximamente desde la memoria.
Simula el mecanismo de prefetch por hardware de las CPU modernas.
        """

        print(f"\n[Prefetch DMA] Precargando en la caché las direcciones de memoria {start_addr}~{start_addr+count-1}...)
        for i in range(count):
            addr = start_addr + i
            data = memory.read(addr)
            line_index = addr % cache.num_lines
            cache.lines[line_index] = (addr, data)
        print(f" [Prefetch DMA] Completo, {count} instrucciones escritas en la caché")


# ============================
# 4. ALU: Unidad Aritmético-Lógica
# ============================

class ALU:
    """
Unidad Aritmético-Lógica: ejecuta todas las operaciones aritméticas y lógicas.
Corresponde al contenido del segundo módulo del curso, como sumadores y puertas lógicas.
    """

    @staticmethod
    def add(a, b):
        print(f" [ALU] Ejecutando suma: {a} + {b} = {a + b}")
        return a + b

    @staticmethod
    def sub(a, b):
        print(f" [ALU] Ejecutando resta: {a} - {b} = {a - b}")
        return a - b

    @staticmethod
    def mul(a, b):
        print(f" [ALU] Ejecutando multiplicación: {a} * {b} = {a * b}")
        return a * b

    @staticmethod
    def cmp(a, b):
        result = (a == b)
        print(f" [ALU] Ejecutando comparación: {a} == {b} ? {'Sí' if result else 'No'} (Z={1 if result else 0})")
        return result


# ============================
# 5. FullComputer: computadora completa
# ============================

class FullComputer:
    """
Simulador completo de una computadora von Neumann.

Componentes:
- disk: disco duro (almacenamiento persistente)
- memory: memoria principal
- cache: caché L1
- registers: conjunto de registros (incluye PC, IR, MAR, MDR, FLAGS)
- alu: unidad aritmético-lógica
- bus: bus del sistema (direcciones + datos + control)
- dma: controlador DMA

Flujo de ejecución:
1. Carga: el DMA mueve el programa del disco duro a la memoria
2. Ciclo: búsqueda de instrucción → decodificación → ejecución → escritura de vuelta (write-back)
3. Generar informe completo de ejecución
    """


    def __init__(self):
        print("=" * 60)
        print(" FullComputer - Inicializando computadora de von Neumann...")
        print("=" * 60)

        # Sistema de almacenamiento de cuatro niveles
        self.disk = Disk()
        self.memory = Memory()
        self.cache = Cache(num_lines=8)
        self.registers = RegisterFile()

        # Unidad de cómputo
        self.alu = ALU()

        # Sistema de buses
        self.bus = SystemBus()

        # Controlador DMA
        self.dma = DMAController(self.bus)

        # Información estadística
        self.instructions_executed = 0
        self.clock_cycles = 0

        print(" Componentes listos: disco duro, memoria (64KB), caché (8 líneas L1), 4 registros de propósito general")
        print(" Componentes listos: ALU, bus del sistema, controlador DMA")
        print()

    def store_program(self, name, program):
        """Almacenar el programa en el disco duro"""
        print(f"[Paso 0] Almacenar el programa '{name}' en el disco duro")
        self.disk.store_program(name, program)
        print()

    def load_program(self, program_name, load_addr=0):
        """
Cargar programa: el DMA lo mueve del disco duro a la memoria.
        """

        print(f"[Paso 1] El DMA carga el programa en la memoria")
        size = self.dma.transfer_program(
            self.disk, program_name, self.memory, load_addr
        )
        print()

        # Prefetch de instrucciones a la caché
        print(f"[Paso 2] Precalentamiento de caché: prefetch de las primeras {min(4, size)} instrucciones")
        self.dma.cache_prefetch(self.memory, self.cache, load_addr, min(4, size))
        print()

        # Establecer el PC en la dirección de inicio del programa
        self.registers.PC = load_addr
        print(f"[Paso 3] Establecer PC ← {load_addr} (dirección de inicio del programa)")
        print()

    def fetch(self):
        """
Fase 1: Búsqueda (Fetch)
- Colocar el valor del PC en el MAR
- Enviar la dirección a través del bus de direcciones
- Enviar la señal READ a través del bus de control
- Obtener la instrucción del bus de datos (a través de la capa de caché)
- Almacenar la instrucción en el IR
- Incrementar el PC
        """

        print(f"--- Fase 1: Búsqueda (Fetch) ---")
        self.clock_cycles += 1

        # MAR ← PC
        self.registers.MAR = self.registers.PC
        print(f"  MAR ← PC = {self.registers.PC}")

        # Leer de la memoria a través del bus (pasando por la caché)
        instruction = self.bus.cpu_read(
            self.registers.MAR, self.memory, self.cache
        )

        # MDR ← bus de datos, IR ← MDR
        self.registers.MDR = instruction
        self.registers.IR = instruction
        print(f"  MDR ← {instruction}, IR ← MDR")

        # El PC se incrementa
        old_pc = self.registers.PC
        self.registers.PC += 1
        print(f"  PC ← {old_pc} + 1 = {self.registers.PC}")

        return instruction

    def decode(self):
        """
Fase 2: Decodificación (Decode)
- El controlador decodifica la instrucción en el IR
- Separa el opcode y los operandos
- Determina la operación de la fase de ejecución
        """

        print(f"--- Fase 2: Decodificación (Decode) ---")
        self.clock_cycles += 1

        instruction = self.registers.IR
        parts = instruction.split()
        opcode = parts[0]
        operands = parts[1:] if len(parts) > 1 else []

        print(f" Instrucción: '{instruction}'")
        print(f" Opcode: {opcode}, Operandos: {operands}")

        return opcode, operands

    def execute(self, opcode, operands):
        """
Fase 3: Ejecución (Execute)
- Ejecuta la operación correspondiente según el opcode
- La ALU participa en operaciones aritméticas/lógicas
- Puede modificar registros o establecer banderas (flags)
        """

        print(f"--- Fase 3: Ejecución (Execute) ---")
        self.clock_cycles += 1

        if opcode == 'LOAD':
            # LOAD reg value: Carga un valor inmediato en el registro
            reg, value = operands[0], int(operands[1])
            self.registers.gpr[reg] = value
            print(f" Operación: cargar inmediato {value} → registro {reg}")
            print(f" La ALU no participa (carga directa)")

        elif opcode == 'STORE':
            # STORE reg addr: Almacena el valor del registro en memoria
            reg, addr = operands[0], int(operands[1])
            value = self.registers.gpr[reg]
            print(f" Operación: preparar para almacenar el valor {value} del registro {reg} en la dirección de memoria {addr}")
            # Los datos están listos, la fase de write-back ejecuta la operación de almacenamiento real
            return ('STORE', reg, addr, value)

        elif opcode == 'ADD':
            # ADD dst src: dst = dst + src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.add(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            # Establecer la bandera de cero (zero flag)
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operación: {dst} ← {old_val} + {self.registers.gpr.get(src, src)} = {result}")
            print(f" Bandera de cero Z ← {self.registers.FLAGS['Z']}")

        elif opcode == 'SUB':
            # SUB dst src: dst = dst - src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.sub(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operación: {dst} ← {old_val} - {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'MUL':
            # MUL dst src: dst = dst * src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.mul(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operación: {dst} ← {old_val} * {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'CMP':
            # CMP a b: Compara dos valores de registro, establece la bandera de cero
            a, b = operands[0], operands[1]
            is_equal = self.alu.cmp(
                self.registers.gpr[a],
                self.registers.gpr[b]
            )
            self.registers.FLAGS['Z'] = is_equal

        elif opcode == 'JMP':
            # JMP addr: Salto incondicional
            target = int(operands[0])
            print(f" Operación: salto incondicional a la dirección {target}")
            old_pc = self.registers.PC
            self.registers.PC = target
            print(f" PC ← {old_pc} → {target} (salto)")

        elif opcode == 'JZ':
            # JZ addr: Salta si la bandera de cero es verdadera
            target = int(operands[0])
            if self.registers.FLAGS['Z']:
                print(f" Operación: bandera de cero verdadera (Z=1), salta a la dirección {target}")
                self.registers.PC = target
            else:
                print(f" Operación: bandera de cero falsa (Z=0), no salta, ejecución secuencial")

        elif opcode == 'HALT':
            # HALT: Detenerse
            print(f" Operación: instrucción de detención, fin del programa")
            return 'HALT'

        else:
            print(f" Opcode desconocido: {opcode}")

        return None

    def writeback(self):
        """
Fase 4: WriteBack
- Si hay operaciones que necesitan escribir de vuelta a memoria (como STORE), se completan en esta fase
- Transferencia de datos a través del bus de datos
        """

        print(f"--- Fase 4: WriteBack ---")
        self.clock_cycles += 1

        # El resultado de las instrucciones generales ya se escribió en los registros en la fase de ejecución
        # La instrucción STORE necesita escribir en memoria en esta fase
        print(f" Estado de registros: {self.registers.gpr}")
        print(f" Registro de banderas: {self.registers.FLAGS}")

    def writeback_store(self, addr, value):
        """Operación de write-back de la instrucción STORE——escribir en memoria a través del bus"""
        self.bus.cpu_write(addr, value, self.memory)
        print(f" STORE completado: {value} → dirección de memoria {addr}")

    def run(self):
        """
Ejecutar el programa cargado.
Ciclo: fetch → decodificación → ejecución → write-back hasta que el programa termine.
        """

        print("=" * 60)
        print(" El programa comienza a ejecutarse")
        print("=" * 60)

        while self.registers.PC < max(self.memory.cells.keys(), default=0) + 1:
            # Verificar si el PC está en un rango válido
            if self.registers.PC not in self.memory.cells:
                # El PC está fuera del rango del programa, posiblemente porque se saltó al final, fin
                print(f"\n"El contador de programa PC={self.registers.PC} está fuera del rango del programa, fin de la ejecución")
                break

            self.instructions_executed += 1

            print(f"\n{'#' * 55}")
            print(f"### Instrucción #{self.instructions_executed} | PC = {self.registers.PC}")
            print(f"{'#' * 55}")

            # Fetch
            instruction = self.fetch()

            # Decodificación
            opcode, operands = self.decode()

            # Ejecución
            special = self.execute(opcode, operands)

            # Manejar la instrucción HALT
            if special == 'HALT':
                self.clock_cycles += 1
                break

            # WriteBack
            if special and special[0] == 'STORE':
                _, reg, addr, value = special
                self.writeback_store(int(addr), value)
            else:
                self.writeback()

            # Verificación de seguridad: evitar bucles infinitos
            if self.instructions_executed > 1000:
                print("\n"Advertencia: se han ejecutado más de 1000 instrucciones, detención forzada (posible bucle infinito)")
                break

        print(f"\n{'=' * 60}")
        print(f" El programa ha terminado de ejecutarse")
        print(f"{'=' * 60}")

    def report(self):
        """
Generar un informe de ejecución completo.
Resumir todas las estadísticas: tasa de aciertos de caché, número de instrucciones, ciclos de reloj,
Número de transferencias de bus, número de lecturas/escrituras de memoria, etc.
        """

        print(f"\n{'=' * 65}")
        print(f" Informe de ejecución de FullComputer —— EJEMPLO")
        print(f"{'=' * 65}")
        print()

        # Información básica
        print(f"  {'─' * 55}")
        print(f" Información básica")
        print(f"  {'─' * 55}")
        print(f" Total de instrucciones ejecutadas: {self.instructions_executed:>6d}")
        print(f" Ciclos de reloj totales: {self.clock_cycles:>6d}")
        if self.instructions_executed > 0:
            cpi = self.clock_cycles / self.instructions_executed
            print(f" CPI promedio (ciclos/instrucción): {cpi:>6.2f}")
        print()

        # Rendimiento de la caché
        print(f"  {'─' * 55}")
        print(f" Rendimiento de la caché (L1 Cache)")
        print(f"  {'─' * 55}")
        total_access = self.cache.hit_count + self.cache.miss_count
        print(f" Aciertos de caché: {self.cache.hit_count:>6d}")
        print(f" Fallos de caché: {self.cache.miss_count:>6d}")
        print(f" Accesos totales: {total_access:>6d}")
        print(f" Tasa de aciertos: {self.cache.hit_rate:>6.1f}%")
        print(f" Total de líneas de caché: {self.cache.num_lines:>6d}")
        print()

        # Acceso a memoria
        print(f"  {'─' * 55}")
        print(f" Estadísticas de acceso a memoria")
        print(f"  {'─' * 55}")
        print(f" Lecturas de memoria: {self.memory.read_count:>6d}")
        print(f" Escrituras de memoria: {self.memory.write_count:>6d}")
        print(f" Accesos totales a memoria: {self.memory.read_count + self.memory.write_count:>6d}")
        print(f" Direcciones de memoria en uso: {len(self.memory.cells):>6d}")
        print()

        # Estadísticas del bus
        print(f"  {'─' * 55}")
        print(f" Estadísticas del bus")
        print(f"  {'─' * 55}")
        print(f" Transferencias de bus iniciadas por CPU: {self.bus.transfer_count:>6d}")
        print(f" Transferencias de bus iniciadas por DMA: {self.dma.transfer_count:>6d}")
        total_bus = self.bus.transfer_count + self.dma.transfer_count
        print(f" Total de transferencias de bus: {total_bus:>6d}")
        print()

        # Estado final de los registros
        print(f"  {'─' * 55}")
        print(f" Estado final de los registros")
        print(f"  {'─' * 55}")
        print(f" Registros generales: {self.registers.gpr}")
        print(f" Contador de programa PC: {self.registers.PC}")
        print(f" Registro de instrucción IR: {self.registers.IR}")
        print(f" Registro de banderas FLAGS: {self.registers.FLAGS}")
        print()

        # Volcado de datos de memoria (solo muestra datos de direcciones válidas)
        print(f"  {'─' * 55}")
        print(f" Volcado de datos de memoria (solo muestra el área del programa)")
        print(f"  {'─' * 55}")
        if self.memory.cells:
            for addr in sorted(self.memory.cells.keys()):
                val = self.memory.cells[addr]
                print(f" Dirección {addr:>4d} (0x{addr:04X}): {val}")
        else:
            print(f" (Memoria vacía)")
        print()

        print(f"{'=' * 65}")
        print(f" Fin del informe. ¡Gracias por usar el simulador EJEMPLO FullComputer!")
        print(f"{'=' * 65}")


# ============================
# 6. Programa principal - Demostración de extremo a extremo
# ============================

if __name__ == "__main__":
    print()
    print("╔" + "═" * 58 + "╗")
    print("║" + " El viaje completo de una instrucción —— Demostración de EJEMPLO FullComputer ".center(52) + "║")
    print("╚" + "═" * 58 + "╝")
    print()

    # Crear la computadora
    computer = FullComputer()

    # Definir el programa de demostración: calcular (10 + 7) * 2 - 3 = ?
    # Usar LOAD para cargar valores iniciales, usar ADD/MUL/SUB para completar el cálculo
    demo_program = [
        "LOAD A 10",    # A = 10
        "LOAD B 7",     # B = 7
        "ADD A B",      # A = A + B = 17
        "LOAD C 2",     # C = 2
        "MUL A C",      # A = A * C = 34
        "LOAD D 3",     # D = 3
        "SUB A D",      # A = A - D = 31
        "STORE A 100",  # Almacenar el resultado en la dirección de memoria 100
        "LOAD B 31",    # B = 31 (resultado esperado)
        "CMP A B",      # Comparar A y B -> deberían ser iguales
        "JZ 12",        # Si son iguales (Z=1), saltar a HALT
        "LOAD D 0",     # (No se ejecuta) D = 0
        "HALT",         # Detenerse
    ]

    # Paso 1: Almacenar el programa en el disco duro
    computer.store_program("EJEMPLO_DEMO", demo_program)

    # Paso 2: DMA carga en memoria
    computer.load_program("EJEMPLO_DEMO", load_addr=0)

    # Paso 3: Ejecutar el programa
    computer.run()

    # Paso 4: Imprimir el informe de ejecución completo
    computer.report()

    print(f"\n")
    print(fRepaso de conocimientos: esta demostración cubre los seis módulos completos de los principios de organización del computador:)
    print(fMódulo 1 (Binario): las instrucciones y los datos se almacenan codificados en binario en la memoria)
    print(fMódulo 2 (Puertas lógicas): ADD/SUB/MUL en la fase de ejecución se realizan mediante los circuitos de puertas de la ALU)
    print(fMódulo 3 (Von Neumann): el programa y los datos comparten memoria, los cinco componentes principales trabajan en conjunto)
    print(fMódulo 4 (Principios de la CPU): PC busca instrucción → IR decodifica → ALU ejecuta → retroescritura, cuatro fases completas)
    print(fMódulo 5 (Sistema de almacenamiento): disco duro → memoria → caché → registros, jerarquía de almacenamiento de cuatro niveles)
    print(fMódulo 6 (Bus y E/S): interacción de los tres buses, carga de programas por DMA, notificación por interrupción)
    print()

Interpretación del informe de ejecución

Después de ejecutar el código anterior, FullComputer generará un informe de ejecución detallado. Interpretemos sus indicadores clave:

Tasa de aciertos de caché

La tasa de aciertos de caché que muestra el informe refleja lalocalidad temporalylocalidad espacial. Debido a que nuestro programa de demostración es muy pequeño y DMA precargó las primeras 4 instrucciones, la tasa de aciertos será alta. En programas grandes reales, la tasa de aciertos de caché suele ser superior al 90% — este es precisamente el propósito de la caché.

CPI (ciclos de reloj por instrucción)

En nuestra simulación simplificada, cada instrucción tiene fijados 4 ciclos de reloj (buscar-decodificar-ejecutar-escribir), por lo que el CPI es aproximadamente 4. Las CPU modernas, mediante la tecnología de pipeline, pueden reducir el CPI a cerca de 1 — es decir, completar una instrucción en cada ciclo de reloj.

Número de transferencias por bus

Número de transferencias del bus = transferencias iniciadas por la CPU + transferencias iniciadas por DMA. El DMA realiza una gran cantidad de transferencias durante la fase de carga del programa, y la CPU inicia al menos una transferencia de lectura en la fase de búsqueda de cada instrucción.


Qué hemos aprendido: repaso del curso de seis semanas

Hace seis semanas comenzamos con la pregunta más simple: «¿por qué la computadora solo reconoce 0 y 1?». Ahora ya somos capaces de construir desde cero un simulador completo de computadora. Repasemos nuevamente esta ruta de aprendizaje:

SemanaMóduloAprendizaje principal
Semana 1Binario y representación de la informaciónComprendimos por qué la computadora usa binario, cómo realizar conversiones entre bases, y cómo diversos tipos de información (números, texto, imágenes) se codifican en 0 y 1
Semana 2Puertas lógicas y circuitos digitalesDominamos las tres puertas lógicas básicas (AND, OR, NOT) y comprendimos cómo utilizarlas para construir sumadores y la ALU
Semana 3Arquitectura de Von NeumannComprendimos la división de funciones de los cinco componentes principales (unidad aritmético-lógica, unidad de control, memoria, entrada, salida) y la idea del «programa almacenado»
Semana 4Principios de la CPUDominamos las cuatro fases del ciclo de instrucción: búsqueda-decodificación-ejecución-escritura, y cómo la tecnología de pipeline mejora la eficiencia
Semana 5Sistema de almacenamientoComprendimos la pirámide de almacenamiento de cuatro niveles, desde los registros hasta el disco duro, y cómo la caché utiliza el principio de localidad para acelerar el acceso
Semana 6Bus y E/SDominamos el trabajo coordinado de los tres tipos de bus (direcciones/datos/control) y las diferencias de eficiencia entre los tres modos de E/S (polling/interrupción/DMA)

De la teoría a la práctica: hacia dónde ir a continuación

Este curso te ha proporcionado una base sólida en los principios de organización de computadoras. Si te interesa profundizar, estas son algunas direcciones recomendadas:

  • Sistemas operativos: aprende cómo el sistema operativo gestiona la CPU, la memoria, el sistema de archivos y los dispositivos de E/S. Los conceptos de «interrupción», «DMA» y «jerarquía de memoria» que estudiaste en este curso son conceptos centrales de los sistemas operativos.
  • Lenguaje ensamblador: interactúa directamente con las instrucciones de la CPU. Después de completar este curso, el lenguaje ensamblador ya no es un «libro incomprensible»: sabes cómo se ejecuta cada instrucción ensambladora a nivel de hardware.
  • nand2tetris: un famoso curso en línea que te lleva desde una sola puerta NAND hasta construir gradualmente una computadora programable completa. El contenido de este curso es altamente complementario.
  • Arquitectura de computadoras: profundiza en técnicas avanzadas de diseño de CPU como pipeline, superescalar, ejecución fuera de orden y predicción de salto.
  • Sistemas embebidos: aplica los conocimientos de este curso en microcontroladores (como Arduino, STM32), escribiendo programas que manipulen directamente registros y periféricos.

Resumen y verificación final

Resumen en una frase:La computadora no es magia: es una abstracción cuidadosamente diseñada capa por capa, que comienza con los interruptores de transistores y construye progresivamente puertas lógicas, ALU, CPU, sistema de memoria y buses, hasta conformar finalmente una máquina universal capaz de ejecutar cualquier programa. Si entiendes estas capas, entonces realmente entiendes la computadora.

Autoevaluación integral del curso

  1. En el simulador FullComputer, durante la ejecución de una instrucción LOAD, ¿en qué pasos se utilizan respectivamente el bus de direcciones, el bus de datos y el bus de control?
  2. ¿Qué impacto tendría en la eficiencia de ejecución del programa que la caché de FullComputer tuviera solo 4 líneas (en lugar de 8)? ¿Cómo se denomina este fenómeno en la arquitectura de computadoras?
  3. ¿En qué escenarios utiliza el sistema operativo moderno el polling, las interrupciones y el DMA? Proporciona un ejemplo de cada uno que puedas observar al usar una computadora en tu vida diaria.

Respuestas de referencia: 1. Fase de búsqueda: el bus de direcciones transmite el valor del PC (dirección de la instrucción), el bus de control envía la señal READ y el bus de datos devuelve el contenido de la instrucción. 2. Hay más conflictos de caché y la tasa de aciertos disminuye (denominado thrashing de caché o fallos de conflicto). 3. Polling: comprobación del progreso durante la actualización de firmware en algunos dispositivos embebidos simples; Interrupción: cada pulsación de tecla del teclado genera una interrupción; DMA: copia de archivos grandes, transferencia del búfer de fotogramas de renderizado de la tarjeta gráfica.

Otras extensiones