Tres métodos de E/S -- sondeo, interrupción, DMA
En la clase anterior aprendimos cómo la CPU y la memoria se comunican a través del bus. Pero una computadora no es solo CPU más memoria: también necesita intercambiar datos con diversos dispositivos externos (dispositivos de E/S) como teclado, ratón, disco duro y tarjeta de red.
La CPU tiene tres formas básicas de intercambiar datos con dispositivos externos:Sondeo (Polling)、Interrupción (Interrupt)、DMA (Acceso directo a memoria)La eficiencia de los tres es enormemente diferente: elegir qué método se usa a menudo determina el rendimiento de todo el sistema.
Esta clase usa tres escenarios cotidianos para ayudarte a desarrollar intuición y luego usa código Python para comparar visualmente las diferencias de eficiencia entre los tres métodos.
Analogía con tres escenarios cotidianos
Escenario uno: sondeo: revisar cada 5 segundos si el agua ya hirvió
Estás hirviendo agua en la cocina, pero la tetera no tiene silbato. Cada 5 segundos corres desde la sala a la cocina para mirar: "¿Ya hirvió el agua? ¿Ya hirvió? ¿Ya hirvió?"
Durante este tiempo, túno puedes ver la televisión con tranquilidad, porque tienes que ir cada pocos segundos. Empleas casi todo el tiempo en "comprobar el estado".
Esto essondeo: la CPU comprueba en bucle continuamente si el dispositivo está listo, desperdiciando tiempo en consultas sin sentido.
Escenario dos: interrupción: apagar el fuego cuando suena el silbato de la tetera
Esta vez la tetera tiene silbato. Pones el agua al fuego y vuelves a la sala a ver la televisión tranquilamente. Cuando el agua hierve, el silbato suena agudamente. Pausas la televisión, vas a la cocina a apagar el fuego y luego sigues viendo la televisión.
túLa gran mayoría del tiempo se dedica a hacer algo útil(ver la televisión), solo te interrumpen un momento en el instante clave.
Esto esinterrupción: la CPU ejecuta el programa con normalidad; cuando el dispositivo está listo, envía activamente una señal para avisar a la CPU. La CPU pausa su trabajo actual, procesa los datos del dispositivo y luego reanuda el trabajo anterior.
Escenario tres: DMA: contratar directamente una empresa de mudanzas, no tienes que mover un dedo
Vas a mudarte y hay un camión lleno de muebles que transportar de la casa vieja a la nueva. Si los llevas uno por uno tú mismo (modo de interrupción), tendrías que ir y venir decenas de veces.
Contratas una empresa de mudanzas (controlador DMA), les dices: "La dirección de la casa vieja es X, la de la nueva es Y, hay Z muebles en total". Luego sigues con tus asuntos. Cuando la empresa termina todo, te llama y dice "mudanza completada".
Esto esDMA: el controlador DMA dedicado gestiona directamente la transferencia de datos entre la memoria y los periféricos, sin que la CPU participe. Cuando la transferencia termina, el controlador DMA envía una interrupción a la CPU para notificarlo.
Diferencias esenciales entre los tres métodos
| Característica | Sondeo (Polling) | Interrupción (Interrupt) | DMA |
|---|---|---|---|
| Participación de la CPU | Ocupada todo el tiempo, comprobando sin parar | Participación breve durante la transferencia | Casi no participa, solo recibe la notificación de finalización |
| Quién mueve los datos | La CPU mueve personalmente cada byte | La CPU mueve personalmente cada byte | El controlador DMA los mueve, la CPU no interviene |
| Tiempo libre de la CPU | Casi ninguno | Libre la mayor parte del tiempo | Libre casi todo el tiempo |
| Complejidad de implementación | La más simple | Requiere hardware de controlador de interrupciones | Requiere hardware de controlador DMA |
| Latencia de respuesta | Depende del intervalo de sondeo | Nivel de microsegundos | Depende de la duración total de la transferencia DMA |
| Cantidad de datos adecuada | Cantidad muy pequeña | Cantidad pequeña o mediana (nivel KB) | Cantidad grande (nivel MB/GB) |
| Escenario típico | Sistemas embebidos simples, esperas muy cortas | Entrada de teclado, movimiento del ratón, llegada de paquetes de red | Lectura/escritura de disco, framebuffer de tarjeta gráfica, paquetes grandes de tarjeta de red |
Cada vez que pulsas una tecla se dispara una interrupción; cuando copias un archivo grande se usa DMA. Los sistemas operativos modernos eligen automáticamente la mejor opción entre los tres métodos según la cantidad de datos y el escenario.
Visualización de línea de tiempo: comparación entre CPU ocupado e inactivo
Supongamos que hay que leer 4 bloques de datos del disco duro a la memoria. Usamos una línea de tiempo en ASCII para comparar visualmente el estado de la CPU en los tres métodos:
任务: 从硬盘读取 4 个数据块到内存
【轮询 - CPU 几乎全程忙碌】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU: [查][查][搬][查][查][搬][查][查][搬][查][查][搬]
忙 忙 忙 忙 忙 忙 忙 忙 忙 忙 忙 忙
↑ 几乎没有任何空闲
【中断 - CPU 大部分时间空闲】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU: [工作][等待...][搬][工作] [等待...][搬][工作]
忙 闲 忙 忙 闲 忙 忙
↑ 中断触发 ↑ 中断触发
【DMA - CPU 几乎全程空闲】
时间: 0----1----2----3----4----5----6----7----8----9----10--->
CPU: [设置DMA][工作][工作][工作] [被通知完成]
忙 忙 忙 忙 忙
DMA: [搬][搬][搬][搬] ↑ DMA 完成后中断
忙 忙 忙 忙
↑ CPU 完全不管传输过程
Queda claro de un vistazo: con sondeo la CPU queda atada; con interrupción solo se interrumpe brevemente; con DMA la CPU queda casi totalmente liberada.
Demostración de código: Python simula tres modos de E/S e imprime la línea de tiempo
El siguiente código simula el proceso de transferencia del mismo lote de datos usando los tres métodos: sondeo, interrupción y DMA. Calcula el porcentaje de tiempo en que la CPU está ocupada/inactiva y usa una línea de tiempo ASCII para mostrar las diferencias visualmente.
Ejemplo
Comparación de los tres métodos de E/S: sondeo vs interrupción vs DMA (demo de ejemplo)
Este programa simula el escenario en que la CPU transfiere 10 bloques de datos desde un "dispositivo externo" a la memoria,
se completa con los tres métodos: sondeo, interrupción y DMA, e imprime la línea de tiempo para comparar visualmente el estado de la CPU.
Métrica clave: porcentaje de tiempo de CPU ocupada. Cuanto mayor sea el porcentaje, más lastrada está la CPU por la E/S.
"""
import time
import random
class IODevice:
"""Simula un dispositivo de E/S externo (como disco duro, teclado, etc.)"""
def __init__(self, name="Disco duro", response_time=4):
"""
name: nombre del dispositivo
response_time: número de "unidades de tiempo" que tarda el dispositivo en responder
"""
self.name = name
self.response_time = response_time # Tiempo de preparación del dispositivo por cada bloque de datos
self.data_buffer = [] # Búfer de datos interno del dispositivo
self.ready = False # Si el dispositivo está listo
def prepare_data(self, block_id):
"""
El dispositivo prepara los datos: simula el proceso interno del dispositivo.
En el hardware real, este paso corresponde a operaciones como la búsqueda en el disco duro o la recepción de paquetes en la tarjeta de red.
"""
self.ready = False
data = f"DATA_BLOCK_{block_id:02d}"
self.data_buffer.append(data)
# Simula que el dispositivo está listo después de diferentes unidades de tiempo
return data
def is_ready(self):
"""La CPU comprueba este estado durante el sondeo"""
return self.ready
def mark_ready(self):
"""El dispositivo termina de prepararse y envía una señal de interrupción"""
self.ready = True
def get_data(self):
"""Toma un bloque de datos del búfer del dispositivo"""
if self.data_buffer:
return self.data_buffer.pop(0)
return None
class Timeline:
"""
Registrador de línea de tiempo: registra el estado de la CPU y el DMA en cada unidad de tiempo
Se usa para dibujar la línea de tiempo ASCII al final
"""
def __init__(self):
self.cpu_states = [] # Estado de la CPU en cada unidad de tiempo: 'BUSY' o 'IDLE'
self.dma_states = [] # Estado del DMA en cada unidad de tiempo
self.events = [] # Registro de eventos: (tiempo, descripción)
def record_cpu(self, state):
self.cpu_states.append(state)
def record_dma(self, state):
self.dma_states.append(state)
def log_event(self, time_unit, desc):
self.events.append((time_unit, desc))
def draw(self, title="Línea de tiempo"):
"""Dibuja la línea de tiempo ASCII"""
total = len(self.cpu_states)
if total == 0:
print(" (sin datos de tiempo)")
return
print(f"\n ╔══ {title} ══╗")
print(f" ║ Unidades de tiempo totales: {total}")
# Línea de estado de la CPU
cpu_line = "CPU: "
for s in self.cpu_states:
cpu_line += "[" + ("Ocupado" if s == "BUSY" else "Libre") + "]"
print(f" ║ {cpu_line}")
# Línea de estado del DMA (si hay actividad DMA)
if any(s == "BUSY" for s in self.dma_states):
dma_line = "DMA: "
for s in self.dma_states:
dma_line += "[" + ("Ocupado" if s == "BUSY" else "Libre") + "]"
print(f" ║ {dma_line}")
# Registro de eventos
if self.events:
print(f" ╠══ Registro de eventos ══╣")
for t, desc in self.events:
print(f" ║ T={t}: {desc}")
# Resumen de estadísticas
busy_count = sum(1 for s in self.cpu_states if s == "BUSY")
idle_count = total - busy_count
busy_pct = busy_count / total * 100 if total > 0 else 0
idle_pct = idle_count / total * 100 if total > 0 else 0
print(f" ╠══ Estadísticas ══╣")
print(f" ║ CPU ocupada: {busy_count}/{total} ({busy_pct:.0f}%)")
print(f" ║ CPU libre: {idle_count}/{total} ({idle_pct:.0f}%)")
print(f" ╚{'═' * 20}╝")
return busy_pct
class Memory:
"""Simula la memoria principal"""
def __init__(self):
self.data = {}
def write(self, addr, data):
self.data[addr] = data
def __repr__(self):
return f"Memory({len(self.data)} datos)"
class Controller:
"""Controlador de CPU: simula la ejecución de diferentes modos de E/S"""
def __init__(self):
self.memory = Memory()
self.total_transferred = 0
def simulate_polling(self, device, block_count):
"""
Simulación del modo sondeo:
La CPU comprueba en cada unidad de tiempo si el dispositivo está listo.
Si está listo, mueve un bloque de datos; de lo contrario, continúa comprobando.
"""
print(f"\n{'#'*55}")
print(f"# Método 1: Sondeo (Polling)")
print(f"# Dispositivo: {device.name} | Número de bloques: {block_count}")
print(f"# Estrategia: la CPU verifica el estado del dispositivo en cada unidad de tiempo")
print(f"{'#'*55}")
timeline = Timeline()
time_unit = 0
blocks_done = 0
device_ready_at = 0 # En qué unidad de tiempo el dispositivo prepara el siguiente bloque
# Inicialización: el dispositivo comienza a preparar el primer bloque de datos
device.prepare_data(0)
device_ready_at = time_unit + device.response_time
while blocks_done < block_count:
# La CPU verifica el estado del dispositivo (sondeo)
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
if time_unit >= device_ready_at and device.is_ready():
# Dispositivo listo -> la CPU transfiere los datos
data = device.get_data()
self.memory.write(blocks_done, data)
timeline.log_event(time_unit, f"La CPU transfiere el bloque de datos {blocks_done}: {data}")
blocks_done += 1
self.total_transferred += 1
# Preparar el siguiente bloque de datos (si queda alguno)
if blocks_done < block_count:
device.prepare_data(blocks_done)
device_ready_at = time_unit + device.response_time
else:
# Dispositivo no listo -> la CPU hizo el viaje en vano
timeline.log_event(time_unit,
f"La CPU verifica el dispositivo... {'listo' if device.is_ready() else 'no listo'}")
# El dispositivo trabaja en segundo plano (si está en fase de preparación)
if time_unit == device_ready_at:
device.mark_ready()
timeline.log_event(time_unit, "El dispositivo ha terminado de prepararse, los datos están listos")
time_unit += 1
print(f"\n"Transferencia completada: {self.total_transferred} bloques de datos")
busy_pct = timeline.draw("Línea de tiempo del modo sondeo")
return busy_pct
def simulate_interrupt(self, device, block_count):
"""
Simulación del modo interrupción:
La CPU pasa la mayor parte del tiempo ejecutando otras tareas (marcado como IDLE),
solo pausa su trabajo actual al recibir la señal de interrupción, procesa la transferencia de datos y luego continúa.
"""
print(f"\n{'#'*55}")
print(f"# Método 2: Interrupción (Interrupt)")
print(f"# Dispositivo: {device.name} | Número de bloques de datos: {block_count}")
print(f"# Estrategia: la CPU ejecuta tareas con normalidad; cuando el dispositivo está listo, envía una notificación de interrupción")
print(f"{'#'*55}")
timeline = Timeline()
time_unit = 0
blocks_done = 0
transferred_in_interrupt = 0
device_ready_at = 0
# Inicialización
device.prepare_data(0)
device_ready_at = time_unit + device.response_time
while blocks_done < block_count:
# Por defecto: la CPU está ejecutando otras tareas (inactiva)
if time_unit == device_ready_at:
# El dispositivo está listo, envía la señal de interrupción
device.mark_ready()
timeline.log_event(time_unit, "¡Interrupción disparada! Los datos del dispositivo están listos")
# La CPU responde a la interrupción y transfiere los datos (durante este tiempo, la CPU está ocupada)
data = device.get_data()
for substep in range(2): # El manejo de la interrupción requiere 2 unidades de tiempo
if substep == 0:
timeline.record_cpu("BUSY") # Guardar el contexto y entrar en el manejo de la interrupción
timeline.record_dma("IDLE")
timeline.log_event(time_unit + substep, f"La CPU entra en el manejo de la interrupción")
else:
timeline.record_cpu("BUSY") # Transferir los datos
timeline.record_dma("IDLE")
self.memory.write(blocks_done, data)
transferred_in_interrupt += 1
timeline.log_event(time_unit + substep, f"La CPU transfiere el bloque de datos {blocks_done}: {data}")
blocks_done += 1
# Manejo de interrupción completado; la CPU reanuda su trabajo anterior
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
timeline.log_event(time_unit + 2, "La CPU reanuda su trabajo anterior")
time_unit += 3 # Omitir el tiempo ocupado por el manejo de la interrupción
# Preparar el siguiente bloque
if blocks_done < block_count:
device.prepare_data(blocks_done)
device_ready_at = time_unit + device.response_time
continue
# Fase de ejecución normal: la CPU procesa sus propias tareas
timeline.record_cpu("IDLE")
timeline.record_dma("IDLE")
timeline.log_event(time_unit, "La CPU ejecuta otras tareas (inactiva/programa de usuario)")
time_unit += 1
print(f"\n"Transferencia completada: {self.total_transferred} bloques de datos")
busy_pct = timeline.draw("Línea de tiempo del modo interrupción")
return busy_pct
def simulate_dma(self, device, block_count):
"""
Simulación del modo DMA:
La CPU solo configura el controlador DMA al principio; luego no se involucra en absoluto en la transferencia de datos.
El controlador DMA transfiere todos los bloques de datos de forma autónoma.
Cuando la transferencia se completa, el DMA envía una interrupción para notificar a la CPU.
"""
print(f"\n{'#'*55}")
print(f"# Método 3: DMA (Acceso Directo a Memoria)")
print(f"# Dispositivo: {device.name} | Número de bloques de datos: {block_count}")
print(f"# Estrategia: tras configurar el DMA, la CPU continúa su trabajo; el controlador DMA transfiere los datos automáticamente")
print(f"{'#'*55}")
timeline = Timeline()
time_unit = 0
dma_busy_until = 0
setup_done = False
blocks_to_transfer = list(range(block_count))
dma_buffer = []
# Preparar todos los bloques de datos
for i in range(block_count):
device.prepare_data(i)
while blocks_to_transfer or dma_buffer:
# Fase 1: la CPU configura el controlador DMA (solo una vez, ocupa 2 unidades de tiempo)
if not setup_done:
for substep in range(2):
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
if substep == 0:
timeline.log_event(time_unit,
"La CPU configura el DMA: establece la dirección de origen, la dirección de destino y el número de bytes a transferir")
else:
timeline.log_event(time_unit,
"La CPU inicia la transferencia DMA y luego continúa con su propio trabajo")
time_unit += 1
setup_done = True
dma_busy_until = time_unit + block_count * device.response_time
# Marcar el dispositivo como listo
device.mark_ready()
# Rellenar previamente el búfer DMA
while device.data_buffer:
dma_buffer.append(device.data_buffer.pop(0))
continue
# Fase 2: el controlador DMA transfiere datos de forma autónoma; la CPU está inactiva
if time_unit < dma_busy_until:
timeline.record_cpu("IDLE")
timeline.record_dma("BUSY")
if dma_buffer:
data = dma_buffer.pop(0)
blocks_to_transfer.pop(0)
mem_addr = block_count - len(blocks_to_transfer) - 1
self.memory.write(mem_addr, data)
self.total_transferred += 1
timeline.log_event(time_unit, f"El DMA transfiere el bloque de datos {mem_addr}: {data}")
else:
timeline.log_event(time_unit, "Controlador DMA trabajando...")
else:
# Fase 3: el DMA completa la transferencia y envía una interrupción para notificar a la CPU
timeline.record_cpu("BUSY")
timeline.record_dma("BUSY")
timeline.log_event(time_unit, "Transferencia DMA completada; interrupción notifica a la CPU")
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
timeline.log_event(time_unit + 1, "La CPU confirma que la transferencia se ha completado")
time_unit += 2
break
time_unit += 1
print(f"\n"Transferencia completada: {self.total_transferred} bloques de datos")
busy_pct = timeline.draw("Línea de tiempo del modo DMA")
return busy_pct
# ===== Programa principal: comparación de los tres métodos =====
if __name__ == "__main__":
print("=" * 60)
print(" Comparación de eficiencia de los tres métodos de I/O —— Demostración de Principios de Organización de Computadoras de EJEMPLO")
print("=" * 60)
print()
print("Escenario: transferir 5 bloques de datos desde un dispositivo externo a la memoria")
print("Tiempo de respuesta del dispositivo (unidades de tiempo necesarias para preparar cada bloque de datos): 4")
print()
BLOCK_COUNT = 5
RESPONSE_TIME = 4
results = {}
"# ---- Método 1: Sondeo ----"
dev1 = IODevice("Disco duro", RESPONSE_TIME)
ctrl1 = Controller()
pct1 = ctrl1.simulate_polling(dev1, BLOCK_COUNT)
results["Sondeo"] = pct1
"# ---- Método 2: Interrupción ----"
dev2 = IODevice("Disco duro", RESPONSE_TIME)
ctrl2 = Controller()
pct2 = ctrl2.simulate_interrupt(dev2, BLOCK_COUNT)
results["Interrupción"] = pct2
"# ---- Método 3: DMA ----"
dev3 = IODevice("Disco duro", RESPONSE_TIME)
ctrl3 = Controller()
pct3 = ctrl3.simulate_dma(dev3, BLOCK_COUNT)
results["DMA"] = pct3
"# ---- Comparación final ----"
print("\n" + "=" * 60)
print(" Comparación del porcentaje de tiempo de CPU ocupada entre los tres métodos")
print("=" * 60)
print(fSondeo (Polling): CPU ocupada el {results['轮询']:.0f}% del tiempo)
print(fInterrupción (Interrupt): CPU ocupada {results['Mediocortar']:.0f}% del tiempo)
print(f" DMA: CPU ocupada {results['DMA']:.0f}% del tiempo")
print()
best = min(results, key=results.get)
worst = max(results, key=results.get)
print(f" Mejor método: {best} (menor uso de CPU)")
print(f" Peor método: {worst} (mayor uso de CPU)")
print()
print(f" Conclusión: para grandes volúmenes de transferencia de datos, el uso de CPU con DMA se reduce en comparación con el sondeo")
print(faproximadamente {results['轮询'] - results['DMA']:.0f} puntos porcentuales.)
print(f" Por eso las computadoras modernas usan DMA al transferir archivos grandes.")
print("=" * 60)
Escenarios de aplicación reales en el mundo real
Entrada por teclado: ejemplo típico de interrupción
Cada vez que presionas una tecla, el controlador del teclado envía una señal de interrupción a la CPU. La CPU pausa el programa actual, lee el código de la tecla y luego se reanuda. Este proceso es tan rápido que no percibes ningún retraso.
Si el teclado usara sondeo —la CPU verifica 1000 veces por segundo «¿el usuario presionó una tecla?»— tu computadora se congelaría y no podrías hacer nada.
Copia de archivos grandes: ejemplo típico de DMA
Copias una película de 2GB del disco C al disco D. El controlador del disco duro transfiere los datos directamente a la memoria mediante DMA; la CPU casi no participa en todo el proceso. Incluso puedes navegar por la web o escribir código al mismo tiempo sin que se vea afectado en absoluto.
Sin DMA —la CPU tendría que transferir los 2GB de datos personalmente— durante ese período la CPU prácticamente no podría procesar ninguna otra tarea.
¿Por qué el sondeo no ha sido eliminado?
Aunque el sondeo es el menos eficiente,en sistemas embebidos extremadamente simples,sigue siendo útil:
- Costo de hardware mínimo: no se necesitan controlador de interrupciones ni controlador DMA.
- Para escenarios donde «el dispositivo está listo casi al instante», el costo del sondeo es comparable al de la interrupción, pero su implementación es mucho más simple.
- En algunos sistemas de tiempo real, el determinismo del sondeo (saber exactamente cuándo verificar) tiene más ventaja que la aleatoriedad de las interrupciones.
Resumen y verificación
Resumen en una frase:El sondeo es la CPU preguntando sin cesar «¿ya está?»; la interrupción es el dispositivo que avisa «¡ya estoy listo!»; el DMA es buscar un ayudante que haga el trabajo por ti: cuanto mayor sea la cantidad de datos, más evidente es la ventaja del DMA.
Preguntas de autoevaluación
- Estás escribiendo un documento en la computadora mientras en segundo plano se copia un archivo grande. ¿Qué método de I/O se usa para copiar el archivo? ¿Y cuál se usa cuando escribes en el teclado?
- Si el tiempo de preparación de datos de un dispositivo es extremadamente corto (por ejemplo, solo 1 microsegundo), ¿el sondeo seguiría desperdiciando CPU? ¿Por qué?
- Después de que el controlador DMA completa la transferencia de datos, ¿cómo notifica a la CPU? ¿Qué mecanismo utiliza?
Respuestas de referencia: 1. La copia de archivos usa DMA y la entrada por teclado usa interrupciones. 2. Todavía se desperdicia —porque durante el sondeo la CPU no puede hacer otras cosas; incluso si cada sondeo es rápido, el intervalo de tiempo ocupado no puede usarse para ejecutar programas de usuario—. Pero si el dispositivo es realmente muy rápido, la simplicidad de implementación del sondeo puede ser más ventajosa. 3. Cuando el DMA se completa, notifica a la CPU mediante una interrupción: este es el único momento en que el DMA necesita la participación de la CPU.
Contenido adicional