Trois façons de faire des E/S -- Polling, Interruption, DMA
Dans la leçon précédente, nous avons appris comment le CPU et la mémoire communiquent via le bus. Mais un ordinateur n'est pas seulement un CPU plus de la mémoire — il doit aussi échanger des données avec divers appareils externes (périphériques d'E/S) tels que claviers, souris, disques durs et cartes réseau.
Il existe trois méthodes de base pour que le CPU échange des données avec des périphériques externes :Interrogation、Interruption (Interruption)、DMA (Accès direct à la mémoire)L'efficacité des trois méthodes diffère énormément—celle que vous choisissez détermine souvent les performances de l'ensemble du système.
Dans ce cours, nous utilisons trois scénarios du quotidien pour vous aider à développer votre intuition, puis nous utilisons du code Python pour comparer intuitivement les différences d'efficacité entre les trois méthodes.
Trois analogies de scénarios réels
Scénario 1 : Interrogation—Vérifier toutes les 5 secondes si l'eau bout
Vous faites bouillir de l'eau dans la cuisine, mais la bouilloire n'a pas de sifflet. Toutes les 5 secondes, vous courez du salon à la cuisine pour vérifier : « L'eau bout-elle ? L'eau bout-elle ? L'eau bout-elle ? »
Pendant cette période, vousComplètement incapable de regarder la télévision l'esprit tranquilleParce que vous devez faire un aller-retour toutes les quelques secondes, vous passez presque tout votre temps à « vérifier l'état ».
C'estl'interrogationInterrogation : le CPU boucle continuellement pour vérifier si le périphérique est prêt, perdant du temps sur des requêtes inutiles.
Scénario 2 : Interruption—Éteindre la cuisinière quand le sifflet de la bouilloire retentit
Cette fois, la bouilloire a un sifflet. Après avoir mis l'eau sur la cuisinière, vous retournez au salon et regardez la télévision en toute tranquillité. L'eau bout, et le sifflet retentit fortement. Vous mettez en pause votre émission, allez dans la cuisine pour éteindre la cuisinière, puis continuez à regarder la télévision.
vousLa grande majorité du temps est consacrée à des choses significatives(regarder la télévision), interrompu seulement brièvement aux moments critiques.
C'estl'interruptionInterruption : le CPU exécute normalement son programme ; lorsque le périphérique est prêt, il envoie activement un signal pour notifier le CPU. Le CPU suspend son travail en cours, traite les données du périphérique, puis reprend son travail précédent.
Scénario 3 : DMA—Appelez simplement une société de déménagement, vous n'avez pas à lever le petit doigt
Vous déménagez, avec un chargement de meubles à transporter de l'ancienne maison à la nouvelle. Si vous les transportez vous-même pièce par pièce (la méthode par interruption), vous devez faire des dizaines d'allers-retours.
Vous engagez une entreprise de déménagement (contrôleur DMA) et lui dites : « L'adresse de l'ancienne maison est X, l'adresse de la nouvelle maison est Y, et il y a Z meubles au total. » Puis vous continuez à vous occuper de vos propres affaires. Une fois que l'entreprise de déménagement a tout traité, elle vous appelle et dit « Déménagement terminé. »
Ceci estDMADMA : un contrôleur DMA dédié gère directement le transfert de données entre la mémoire et les périphériques, et le CPU n'a pas du tout besoin de participer. Une fois le transfert terminé, le contrôleur DMA envoie une notification d'interruption au CPU.
Les différences essentielles entre les trois méthodes
| Fonctionnalités | Interrogation | Interrompre | DMA |
|---|---|---|---|
| Implication du CPU | Occupé tout du long, vérifie constamment | Participe brièvement pendant la transmission | Ne participe presque pas, reçoit seulement la notification de fin |
| Qui déplace les données | Le CPU déplace lui-même chaque octet | Le CPU déplace lui-même chaque octet | Le contrôleur DMA effectue le déplacement ; le CPU n'intervient pas |
| Temps d'inactivité du CPU | Presque aucun | Inactif la plupart du temps | Inactif presque tout le temps |
| Complexité d'implémentation | Le plus simple | Nécessite un contrôleur d'interruptions matériel | Nécessite un contrôleur DMA matériel |
| Latence de réponse | Dépend de l'intervalle de scrutation | De l'ordre de la microseconde | Dépend de la durée totale du transfert DMA |
| Taille des données applicable | Quantité extrêmement faible | Quantités petites à moyennes (niveau KB) | Quantités importantes (niveau MB/GB) |
| Scénarios typiques | Systèmes embarqués simples, attentes extrêmement courtes | Saisie clavier, mouvement de souris, arrivée de paquets réseau | Lectures/écritures disque, framebuffer de carte graphique, gros paquets réseau |
Chaque fois que vous appuyez sur une touche, une interruption est déclenchée ; lorsque vous copiez un fichier volumineux, le DMA est utilisé. Les systèmes d'exploitation modernes choisissent automatiquement le meilleur schéma parmi les trois méthodes en fonction du volume de données et du scénario.
Visualisation chronologique : comparaison des états occupé et inactif du CPU
Supposons que nous devions lire 4 blocs de données depuis le disque dur vers la mémoire. Nous utilisons une chronologie ASCII pour comparer visuellement l'état du CPU selon les trois méthodes :
任务: 从硬盘读取 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 完全不管传输过程
C'est évident au premier coup d'œil : en mode interrogation (polling), le CPU est monopolisé ; en interruption, le CPU n'est que brièvement interrompu ; en DMA, le CPU est presque entièrement libéré.
Démonstration de code : simuler les trois méthodes d'E/S en Python et imprimer la chronologie
Le code ci-dessous simule le transfert du même lot de données en utilisant respectivement l'interrogation active (polling), l'interruption et le DMA, calcule la proportion de temps CPU occupé/inactif, et utilise une chronologie en art ASCII pour montrer intuitivement les différences.
Exemple
Comparaison de trois méthodes d'E/S : polling vs interruption vs DMA (démo d'exemple)
Ce programme simule le scénario dans lequel le CPU transfère 10 blocs de données d'un « périphérique externe » vers la mémoire,
Implémenter en utilisant respectivement le polling, les interruptions et le DMA, puis afficher une chronologie pour comparer visuellement les états du CPU.
Indicateur clé : taux d'occupation du CPU. Plus ce taux est élevé, plus le CPU est fortement ralenti par les E/S.
"""
import time
import random
class IODevice:
"""Simuler des périphériques d'E/S externes (tels que disques durs, claviers, etc.)"""
def __init__(self, name="Disque dur", response_time=4):
"""
name: nom du périphérique
response_time : nombre d'« unités de temps » nécessaires à la réponse du périphérique
"""
self.name = name
self.response_time = response_time # Temps de préparation du périphérique par bloc de données
self.data_buffer = [] # Tampon de données interne du périphérique
self.ready = False # Le périphérique est-il prêt ?
def prepare_data(self, block_id):
"""
Le périphérique prépare les données—simulant le traitement interne du périphérique.
Dans le matériel réel, cette étape implique des opérations telles que la recherche sur disque, la réception de paquets par la carte réseau, etc.
"""
self.ready = False
data = f"DATA_BLOCK_{block_id:02d}"
self.data_buffer.append(data)
# Simuler que les périphériques sont prêts après différentes unités de temps
return data
def is_ready(self):
"""Le CPU vérifie cet état lors de l'interrogation"""
return self.ready
def mark_ready(self):
"""Le périphérique a terminé la préparation, envoi du signal d'interruption"""
self.ready = True
def get_data(self):
"""Prendre un bloc de données depuis le tampon du périphérique"""
if self.data_buffer:
return self.data_buffer.pop(0)
return None
class Timeline:
"""
Journaliseur Timeline — enregistre les états CPU et DMA pour chaque unité de temps
Utilisé pour le rendu final de la chronologie ASCII
"""
def __init__(self):
self.cpu_states = [] # État du CPU par unité de temps : 'BUSY' ou 'IDLE'
self.dma_states = [] # État du DMA par unité de temps
self.events = [] # Journal des événements : (temps, description)
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="Chronologie"):
"""Dessiner une chronologie ASCII"""
total = len(self.cpu_states)
if total == 0:
print(" (aucune donnée temporelle)")
return
print(f"\n ╔══ {title} ══╗")
print(f" ║ Unités de temps totales : {total}")
# Ligne d'état CPU
cpu_line = "CPU : "
for s in self.cpu_states:
cpu_line += "[" + ("Occupé" if s == "BUSY" else "Inactif") + "]"
print(f" ║ {cpu_line}")
# Ligne d'état DMA (si une activité DMA existe)
if any(s == "BUSY" for s in self.dma_states):
dma_line = "DMA : "
for s in self.dma_states:
dma_line += "[" + ("Occupé" if s == "BUSY" else "Inactif") + "]"
print(f" ║ {dma_line}")
# Journal des événements
if self.events:
print(f" ╠══ Journal des événements ══╣")
for t, desc in self.events:
print(f" ║ T={t}: {desc}")
# Résumé statistique
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" ╠══ Statistiques ══╣")
print(f║ CPU occupé: {busy_count}/{total} ({busy_pct:.0f}%))
print(f║ CPU inactif: {idle_count}/{total} ({idle_pct:.0f}%))
print(f" ╚{'═' * 20}╝")
return busy_pct
class Memory:
"""Simuler la mémoire principale"""
def __init__(self):
self.data = {}
def write(self, addr, data):
self.data[addr] = data
def __repr__(self):
return fMemory({len(self.data)} éléments de données)
class Controller:
"""Contrôleur CPU — simulation d'exécution de différents modes d'E/S"""
def __init__(self):
self.memory = Memory()
self.total_transferred = 0
def simulate_polling(self, device, block_count):
"""
Simulation de sondage:
Le CPU vérifie si le périphérique est prêt à chaque unité de temps.
Si prêt, déplacer un bloc de données; sinon continuer à vérifier.
"""
print(f"\n{'#'*55}")
print(f"# Méthode 1 : Interrogation")
print(f# Appareil : {device.name} | Nombre de blocs : {block_count})
print(f"# Stratégie : le CPU vérifie l'état de l'appareil à chaque unité de temps")
print(f"{'#'*55}")
timeline = Chronologie()
time_unit = 0
blocks_done = 0
device_ready_at = 0 # À quelle unité de temps l'appareil est prêt pour le bloc suivant
# Initialisation : l'appareil commence à préparer le premier bloc de données
device.prepare_data(0)
device_ready_at = time_unit + device.response_time
while blocks_done < block_count:
# Le CPU vérifie l'état de l'appareil (interrogation)
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
if time_unit >= device_ready_at and device.is_ready():
# Périphérique prêt -> le CPU transfère les données
data = device.get_data()
self.memory.write(blocks_done, data)
timeline.log_event(time_unit, f"CPU a déplacé le bloc de données {blocks_done} : {data}")
blocks_done += 1
self.total_transferred += 1
# Préparer le prochain bloc de données (le cas échéant)
if blocks_done < block_count:
device.prepare_data(blocks_done)
device_ready_at = time_unit + device.response_time
else:
# Périphérique non prêt -> le CPU a fait un déplacement inutile
timeline.log_event(time_unit,
fCPU vérifie le périphérique... {'Prêt' if device.is_ready() else 'Pas prêt'})
# Travail en arrière-plan du périphérique (si en phase de préparation)
if time_unit == device_ready_at:
device.mark_ready()
timeline.log_event(time_unit, Périphérique prêt, données prêtes)
time_unit += 1
print(f"\nTransfert terminé : {self.total_transferred} blocs de données)
busy_pct = timeline.draw("Chronologie du mode d'interrogation")
return busy_pct
def simulate_interrupt(self, device, block_count):
"""
Simulation d'interruption :
Le CPU passe la plupart de son temps à exécuter d'autres tâches (noté IDLE),
Ce n'est qu'après avoir reçu le signal d'interruption qu'il suspend le travail en cours, traite le transfert de données, puis reprend.
"""
print(f"\n{'#'*55}")
print(f# Méthode 2 : Interruption)
print(f# Appareil : {device.name} | Nombre de blocs : {block_count})
print(f# Stratégie : le CPU exécute les tâches normalement et envoie une notification d'interruption lorsque le périphérique est prêt)
print(f"{'#'*55}")
timeline = Chronologie()
time_unit = 0
blocks_done = 0
transferred_in_interrupt = 0
device_ready_at = 0
# Initialiser
device.prepare_data(0)
device_ready_at = time_unit + device.response_time
while blocks_done < block_count:
# Par défaut : le CPU exécute d'autres tâches (inactif)
if time_unit == device_ready_at:
# Périphérique prêt, envoyer le signal d'interruption
device.mark_ready()
timeline.log_event(time_unit, Interruption déclenchée ! Données du périphérique prêtes)
# Le CPU répond à l'interruption et transfère les données (pendant ce temps, le CPU est occupé)
data = device.get_data()
for substep in range(2): # La gestion de l'interruption nécessite 2 unités de temps
if substep == 0:
timeline.record_cpu("BUSY") # Sauvegarder le contexte, entrer dans le traitement de l'interruption
timeline.record_dma("IDLE")
timeline.log_event(time_unit + substep, f"CPU entre dans la gestion des interruptions")
else:
timeline.record_cpu("BUSY") # Déplacer les données
timeline.record_dma("IDLE")
self.memory.write(blocks_done, data)
transferred_in_interrupt += 1
timeline.log_event(time_unit + substep, f"CPU a déplacé le bloc de données {blocks_done}: {data}")
blocks_done += 1
# Traitement de l'interruption terminé, le CPU reprend son travail précédent.
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
timeline.log_event(time_unit + 2, CPU reprend le travail précédent)
time_unit += 3 # Sauter le temps pris par le traitement de l'interruption
# Préparer le bloc suivant
if blocks_done < block_count:
device.prepare_data(blocks_done)
device_ready_at = time_unit + device.response_time
continue
# Phase d'exécution normale — le CPU gère ses propres tâches
timeline.record_cpu("IDLE")
timeline.record_dma("IDLE")
timeline.log_event(time_unit, le CPU exécute d'autres tâches (programme inactif/utilisateur))
time_unit += 1
print(f"\nTransfert terminé : {self.total_transferred} blocs de données)
busy_pct = timeline.draw("Chronologie du mode d'interruption")
return busy_pct
def simulate_dma(self, device, block_count):
"""
Simulation du mode DMA :
Le CPU configure uniquement le contrôleur DMA au début, puis laisse complètement le transfert de données se dérouler seul.
Le contrôleur DMA déplace tous les blocs de données de manière autonome.
Une fois le transfert terminé, le DMA envoie une interruption pour notifier le CPU.
"""
print(f"\n{'#'*55}")
print(f# Méthode 3 : DMA (accès direct à la mémoire))
print(f# Appareil : {device.name} | Nombre de blocs : {block_count})
print(f# Stratégie : le CPU configure le DMA et continue de fonctionner, le contrôleur DMA transfère automatiquement les données)
print(f"{'#'*55}")
timeline = Chronologie()
time_unit = 0
dma_busy_until = 0
setup_done = False
blocks_to_transfer = list(range(block_count))
dma_buffer = []
# Préparer tous les blocs de données
for i in range(block_count):
device.prepare_data(i)
while blocks_to_transfer or dma_buffer:
# Phase 1 : le CPU configure le contrôleur DMA (une seule fois, ce qui prend 2 unités de temps)
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,
Le CPU configure le DMA : définir l'adresse source, l'adresse de destination et le nombre d'octets à transférer)
else:
timeline.log_event(time_unit,
Le CPU lance le transfert DMA, puis poursuit son propre travail)
time_unit += 1
setup_done = True
dma_busy_until = time_unit + block_count * device.response_time
# Marquer le périphérique comme prêt
device.mark_ready()
# Pré-remplir le tampon DMA
while device.data_buffer:
dma_buffer.append(device.data_buffer.pop(0))
continue
# Deuxième phase : le contrôleur DMA transfère les données de manière autonome, le CPU est inactif
if time_unit < dma_busy_until:
timeline.record_cpu("IDLE")
timeline.record_dma("OCCUPÉ")
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, fDMA transfère le bloc de données {mem_addr} : {data})
else:
timeline.log_event(time_unit, "Le contrôleur DMA fonctionne...")
else:
# Étape 3 : DMA terminé, envoie une interruption pour notifier le CPU
timeline.record_cpu("BUSY")
timeline.record_dma("OCCUPÉ")
timeline.log_event(time_unit, "Transfert DMA terminé, l'interruption notifie le CPU")
timeline.record_cpu("BUSY")
timeline.record_dma("IDLE")
timeline.log_event(time_unit + 1, "Le CPU confirme la fin du transfert")
time_unit += 2
break
time_unit += 1
print(f"\nTransfert terminé : {self.total_transferred} blocs de données)
busy_pct = timeline.draw("Chronologie du mode DMA")
return busy_pct
# ===== Programme principal : comparaison de trois approches =====
if __name__ == "__main__":
print("=" * 60)
print(Comparaison de l'efficacité de trois modes d'E/S — démo EXEMPLE Principes d'organisation des ordinateurs)
print("=" * 60)
print()
print(Scénario : transfert de 5 blocs de données d'un périphérique externe vers la mémoire)
print(Temps de réponse du périphérique (unités de temps nécessaires pour préparer chaque bloc de données) : 4)
print()
BLOCK_COUNT = 5
RESPONSE_TIME = 4
results = {}
# ---- Méthode 1 : interrogation ----
dev1 = IODevice("Disque dur", RESPONSE_TIME)
ctrl1 = Controller()
pct1 = ctrl1.simulate_polling(dev1, BLOCK_COUNT)
results["Interrogation"] = pct1
# ---- Méthode 2 : Interruption ----
dev2 = IODevice("Disque dur", RESPONSE_TIME)
ctrl2 = Controller()
pct2 = ctrl2.simulate_interrupt(dev2, BLOCK_COUNT)
results["Interruption"] = pct2
# ---- Méthode 3 : DMA ----
dev3 = IODevice("Disque dur", RESPONSE_TIME)
ctrl3 = Controller()
pct3 = ctrl3.simulate_dma(dev3, BLOCK_COUNT)
results["DMA"] = pct3
# ---- Comparaison finale ----
print("\n" + "=" * 60)
print(Comparaison des taux d'occupation du CPU entre trois méthodes)
print("=" * 60)
print(fPolling : le CPU est occupé {results['polling']:.0f}% du temps)
print(fInterruption : le CPU est occupé {results['interrupt']:.0f}% du temps)
print(fDMA : le CPU est occupé {results['DMA']:.0f}% du temps)
print()
best = min(results, key=results.get)
worst = max(results, key=results.get)
print(f" Meilleure méthode : {best} (utilisation du CPU la plus faible)")
print(f" Pire méthode : {worst} (utilisation du CPU la plus élevée)")
print()
print(fConclusion : Pour les transferts de données volumineux, le DMA réduit l'utilisation du CPU par rapport au polling.)
print(fenviron {results['polling'] - results['DMA']:.0f} points de pourcentage.)
print(f" C'est pourquoi les ordinateurs modernes utilisent le DMA lors du transfert de fichiers volumineux.")
print("=" * 60)
Scénarios d'application pratiques dans le monde réel
Saisie au clavier — un exemple typique d'interruptions
Chaque fois que vous appuyez sur une touche, le contrôleur du clavier envoie un signal d'interruption au CPU. Le CPU suspend le programme en cours, lit le code de la touche, puis reprend. Ce processus est si rapide que vous ne remarquez aucun délai.
Si le clavier utilisait le polling — le CPU vérifiant 1 000 fois par seconde « L'utilisateur a-t-il appuyé sur une touche ? » — votre ordinateur se figerait et vous ne pourriez rien faire.
Copie de gros fichiers — un exemple typique de DMA
Vous copiez un film de 2 Go du disque C vers le disque D. Le contrôleur de disque utilise le DMA pour déplacer directement les données vers la mémoire ; le CPU n'intervient pratiquement pas pendant tout le processus. Vous pouvez aussi naviguer sur le web et écrire du code en même temps, sans aucune gêne.
Sans DMA — le CPU devrait transporter lui-même 2 Go de données — et pendant ce temps, le CPU ne peut pratiquement traiter aucune autre tâche.
Pourquoi le polling n'a-t-il pas été éliminé ?
Bien que le polling soit le moins efficace, il reste utile dans lessystèmes embarqués extrêmement simples:
- Coût matériel le plus faible — aucun contrôleur d'interruptions ni contrôleur DMA n'est nécessaire.
- Dans les scénarios où « le périphérique est prêt presque instantanément », le polling a une surcharge comparable à celle des interruptions, mais est bien plus simple à mettre en œuvre.
- Dans certains systèmes temps réel, le déterminisme du polling (savoir exactement quand vérifier) présente un avantage par rapport au caractère aléatoire des interruptions.
Résumé et vérification
Résumé en une phrase :le polling, c'est le CPU qui ne cesse de demander « OK, déjà ou pas ? » ; l'interruption, c'est le périphérique qui crie de lui-même « E/S prête » ; le DMA, c'est trouver des éléments pour vous aider à faire le travail — plus la quantité de données est grande, plus les avantages du DMA sont évidents.
questions d'auto-évaluation
- Vous utilisez votre ordinateur pour rédiger un document pendant qu'un gros fichier est copié en arrière-plan. Quelle méthode d'E/S est utilisée pour la copie de fichier ? Laquelle est utilisée pour votre saisie au clavier ?
- Si le temps de préparation des données d'un périphérique est extrêmement court (par exemple, seulement 1 microseconde), le polling gaspillerait-il encore du CPU ? Pourquoi ?
- Une fois que le contrôleur DMA a terminé le transfert de données, comment notifie-t-il le CPU ? Quel mécanisme utilise-t-il ?
Réponse de référence: 1. La copie de fichier utilise le DMA, la saisie au clavier utilise les interruptions. 2. Cela gaspille quand même — car pendant le polling, le CPU ne peut pas faire autre chose ; même si chaque interrogation est rapide, le créneau de temps occupé ne peut pas servir à exécuter des programmes utilisateur. Mais si le périphérique est vraiment très rapide, la simplicité de mise en œuvre du polling peut être plus avantageuse. 3. Une fois le DMA terminé, il notifie le CPU via une interruption — c'est le seul moment où le DMA nécessite l'intervention du CPU.
autres extensions