Bus -- le « réseau autoroutier » à l'intérieur d'un ordinateur
Les différents composants à l'intérieur d'un ordinateur doivent constamment échanger des informations. Le CPU doit aller chercher des instructions en mémoire et lire/écrire des données. Comment ces informations sont-elles transmises ? La réponse est —Bus。
Un bus est un ensemble de lignes de communication partagées reliant le CPU, la mémoire, le disque dur, la carte graphique et d'autres dispositifs, tout comme le réseau routier d'une ville — avec des routes principales et des routes secondaires, chacune ayant une fonction précise.
Ce cours vous aidera à comprendre la répartition du travail entre les trois types de bus, et à utiliser Python pour simuler une opération complète de lecture en mémoire.
Analogie avec le réseau autoroutier : trois types de routes, trois types d'usages
Imaginez que vous livrez des colis dans une grande ville. Le coursier doit savoir trois choses :où livrer、Quoi envoyer ?、Le destinataire doit-il signer ?。
À l'intérieur de l'ordinateur, il existe également trois « autoroutes » exactement analogues :
| Type de bus | Fonctionnalités | Sens de transfert | analogie avec la vie |
|---|---|---|---|
| Bus d'adresses | L'adresse mémoire à laquelle accéder pour la transmission | CPU → Mémoire (unidirectionnel) | Le « numéro de maison » sur le bordereau de livraison — indiquant au destinataire « Je cherche cette adresse » |
| Bus de données | Transmettre le contenu réel des données | bidirectionnel | Le « colis » entre les mains du livreur — l'objet lui-même, qui peut être envoyé ou reçu |
| Bus de contrôle | Transmettre des signaux de contrôle tels que lecture/écriture et interruptions | CPU ↔ Composants (bidirectionnel) | Le « reçu » — indiquant à l'autre partie s'il s'agit actuellement d'un ramassage ou d'une livraison, et si le transfert est terminé |
La largeur du bus d'adresses détermine la quantité de mémoire à laquelle le CPU peut accéder. Un bus d'adresses 32 bits peut accéder à 2^32 = 4GB d'espace mémoire, et un bus d'adresses 64 bits peut théoriquement accéder à 2^64 octets (environ 16EB). C'est pourquoi un système d'exploitation 32 bits peut utiliser au maximum 4GB de mémoire.
Déroulement complet d'une opération de lecture mémoire
Supposons que le CPU doive lire une donnée à l'adresse mémoire 100. L'ensemble du processus est divisé en 4 étapes, les trois bus travaillant ensemble :
Décomposition des étapes
- Le CPU place l'adresse: Le CPU place la valeur d'adresse 100 sur lebus d'adresses. La mémoire a maintenant reçu l'adresse.
- Le CPU envoie un signal: Le CPU, au niveau dubus de commande, émet un signal « read » (READ) sur celui-ci. La mémoire sait que l'autre partie veut récupérer quelque chose.
- Stockage des données en mémoire: Après que la mémoire a reçu l'adresse et le signal de lecture, elle trouve les données stockées à l'adresse 100 et les place sur lebus de données.
- Le CPU reçoit les données: Le CPU lit les données depuis le bus de données et les stocke dans un registre interne. Le transfert est terminé.
diagramme de séquence
Le diagramme temporel ASCII suivant montre les changements d'état du bus pendant l'exécution de cette instruction :
时间 | 地址总线 控制总线 数据总线 ------|------------------------------------------ T0 | 100 IDLE XXXX ← CPU 放上地址 T1 | 100 READ XXXX ← CPU 发出读信号 T2 | 100 READ 0x2A ← 内存放上数据 T3 | XXXX IDLE 0x2A ← CPU 取走数据 ------|------------------------------------------ 结果: CPU 从地址 100 读到了数据 0x2A
Démonstration de code : Simulation du processus d'interaction des bus avec Python
Le code Python suivant simule entièrement le processus de collaboration du bus d'adresses, du bus de données et du bus de commande lors d'une opération de lecture mémoire.
Exemple
Simulation d'interaction de bus - Une opération complète de lecture mémoire (démo d'exemple)
Ce programme simule le processus complet de lecture des données depuis la mémoire par le CPU via trois bus :
1. Bus d'adresses : le CPU émet l'adresse mémoire à accéder
2. Bus de contrôle : le CPU émet les signaux de contrôle de lecture/écriture
3. Bus de données : la mémoire renvoie/reçoit les données
Chaque changement d'état d'un bus imprime un journal détaillé, ce qui facilite l'observation du travail collaboratif des trois bus.
"""
import time
class AddressBus:
"""Bus d'adresses - unidirectionnel : le CPU envoie l'adresse à la mémoire"""
def __init__(self):
self.value = None # Valeur d'adresse actuelle sur le bus
self.width = 16 # Bus d'adresses 16 bits, adressable 64KB
def set_address(self, addr):
"""Le CPU place l'adresse sur le bus d'adresses"""
self.value = addr
print(f" [Bus d'adresses] Le CPU place l'adresse : {addr} (0x{addr:04X})")
return addr
def clear(self):
"""Effacer le bus"""
self.value = None
print(f[Bus d'adresses] Bus effacé, passage en état d'inactivité)
class DataBus:
"""Bus de données - Bidirectionnel : le CPU et la mémoire peuvent tous deux envoyer et recevoir des données"""
def __init__(self):
self.value = None # Valeur de données actuelle sur le bus
self.width = 8 # Bus de données 8 bits, transfère un octet à la fois
self.direction = None # 'TO_CPU' ou 'TO_MEMORY'
def send_from_cpu(self, data):
"""Le CPU envoie des données au bus"""
self.value = data
self.direction = 'TO_MEMORY'
print(f" [Bus de données] CPU → Bus, Données : {data} (0x{data:02X})")
return data
def send_from_memory(self, data):
La mémoire envoie des données au bus
self.value = data
self.direction = 'TO_CPU'
print(f[Bus de données] Mémoire → Bus, données : {data} (0x{data:02X}))
return data
def read_to_cpu(self):
"""Le CPU lit des données depuis le bus de données"""
data = self.value
print(f[Bus de données] Le CPU lit les données depuis le bus : {data} (0x{data:02X}))
self.clear()
return data
def read_to_memory(self):
"""La mémoire lit les données depuis le bus de données (utilisé lors des opérations d'écriture)"""
data = self.value
print(f[Bus de données] La mémoire lit les données depuis le bus : {data} (0x{data:02X}))
self.clear()
return data
def clear(self):
"""Effacer le bus"""
self.value = None
self.direction = None
print(f[Bus de données] Bus réinitialisé, passage à l'état inactif)
class ControlBus:
"""Bus de contrôle - bidirectionnel : transmet les signaux de lecture/écriture, les signaux d'interruption, etc."""
# Type de signal de contrôle
READ = 'MEM_READ' # Signal de lecture mémoire
WRITE = 'MEM_WRITE' # Signal d'écriture mémoire
IDLE = 'IDLE' # Inactif
def __init__(self):
self.signal = self.IDLE
def set_signal(self, signal):
"""Définir les signaux de contrôle"""
self.signal = signal
signal_name = {
self.READ: 'Lecture mémoire (MEM_READ)',
self.WRITE: 'Écriture mémoire (MEM_WRITE)',
self.IDLE: 'Inactif (IDLE)'
}
print(f[Bus de contrôle] CPU envoie le signal : {signal_name.get(signal, signal)})
def clear(self):
"""Effacer le signal"""
self.signal = self.IDLE
print(f[Bus de contrôle] Signaux effacés, entrée en état inactif)
class SimpleMemory:
"""Module de mémoire simplifié - 256 octets d'espace de stockage"""
def __init__(self, size=256):
self.size = size
self.data = {}
# Initialiser quelques données de démonstration
for i in range(size):
self.data[i] = i % 256 # L'adresse i stocke la valeur i % 256
# Placer quelques valeurs spéciales à des adresses spécifiques pour la démonstration
self.data[100] = 42 # Adresse 100 : stocker 42 (0x2A)
self.data[200] = 0xAB # Adresse 200 : stocker 0xAB (171)
self.data[50] = ord('R') # Adresse 50 : stocke le code ASCII de la lettre 'R'
self.data[51] = ord('U')
self.data[52] = ord('N')
self.data[53] = ord('O')
self.data[54] = ord('O')
self.data[55] = ord('B')
def read(self, addr):
Lire les données à l'adresse spécifiée
if 0 <= addr < self.size:
return self.data.get(addr, 0)
else:
raise ValueError(fL'adresse {addr} dépasse la plage mémoire (0-{self.size-1}))
def write(self, addr, data):
Écrire les données à l'adresse spécifiée
if 0 <= addr < self.size:
self.data[addr] = data
else:
raise ValueError(fL'adresse {addr} dépasse la plage mémoire (0-{self.size-1}))
class CPU:
"""CPU simplifié - interagit avec la mémoire via le bus"""
def __init__(self, addr_bus, data_bus, ctrl_bus, memory):
self.addr_bus = addr_bus # Bus d'adresse
self.data_bus = data_bus # Bus de données
self.ctrl_bus = ctrl_bus # Bus de contrôle
self.memory = memory # Mémoire
# Registres internes du CPU
self.mdr = 0 # Registre de données (registre de données mémoire)
self.mar = 0 # Registre d'adresse (registre d'adresse mémoire)
def memory_read(self, addr):
"""
Exécuter une opération complète de lecture mémoire
Processus :
T0 : MAR ← addr (préparation interne)
T1 : bus d'adresse ← addr, bus de contrôle ← READ
T2 : la mémoire lit les données, bus de données ← data
T3 : MDR ← bus de données, effacer tous les bus
Retour : la valeur de données lue
"""
print(f"\n{'='*55}")
print(fDébut de l'opération : le CPU lit les données à l'adresse mémoire {addr})
print(f"{'='*55}")
# T0 : préparation interne du CPU — charger l'adresse dans MAR
self.mar = addr
print(f"\n[T0 - préparation interne du CPU]")
print(f[Interne CPU] MAR (registre d'adresse mémoire) ← {addr})
# T1 : le CPU place l'adresse sur le bus d'adresse et émet simultanément un signal de lecture sur le bus de contrôle.
print(f"\n[T1 - Émission de l'adresse et du signal de lecture]")
self.addr_bus.set_address(addr)
self.ctrl_bus.set_signal(ControlBus.READ)
# Simuler le délai de transmission du signal
time.sleep(0.001)
# T2 : Réponse mémoire — en fonction de l'adresse sur le bus d'adresses, trouver les données et les placer sur le bus de données
print(f"\n[T2 - Réponse mémoire]")
data = self.memory.read(addr)
self.data_bus.send_from_memory(data)
# Simuler le délai de transmission du signal
time.sleep(0.001)
# T3 : le CPU lit les données depuis le bus de données vers le MDR. Les bus sont réinitialisés.
print(f"\n[T3 - Le CPU reçoit les données]")
self.mdr = self.data_bus.read_to_cpu()
self.ctrl_bus.clear()
self.addr_bus.clear()
# Afficher le résultat
print(f"\n{'='*55}")
print(f"Opération terminée: fromAddress {addr} (0x{addr:04X}) lecture de toData {self.mdr} (0x{self.mdr:02X})")
print(f"{'='*55}")
return self.mdr
def memory_write(self, addr, data):
"""
Exécuter une opération complète d'écriture en mémoire
Processus :
T0: MAR ← addr, MDR ← data
T1: Bus d'adresse ← addr, Bus de données ← data, Bus de contrôle ← WRITE
T2: La mémoire prend les données du bus de données et écrit à l'adresse addr
T3: Effacer tous les bus
"""
print(f"\n{'='*55}")
print(fDébut de l'opération: le CPU écrit les données {data} à l'adresse mémoire {addr})
print(f"{'='*55}")
# T0: préparation interne du CPU
self.mar = addr
self.mdr = data
print(f"\n[T0 - préparation interne du CPU]")
print(f" [interne CPU] MAR ← {addr}, MDR ← {data}")
# T1 : Le CPU place l'adresse et les données sur le bus et émet un signal d'écriture
print(f"\n[T1 - émission de l'adresse, des données et du signal d'écriture]")
self.addr_bus.set_address(addr)
self.data_bus.send_from_cpu(data)
self.ctrl_bus.set_signal(ControlBus.WRITE)
time.sleep(0.001)
# T2 : La mémoire prend les données du bus de données et les écrit
print(f"\n[T2 - Écriture mémoire]")
received = self.data_bus.read_to_memory()
self.memory.write(addr, received)
print(f" [Intérieur de la mémoire] Adresse {addr} (0x{addr:04X}) ← {received} (0x{received:02X})")
time.sleep(0.001)
# T3 : Effacer tous les bus
print(f"\n[T3 - Effacer le bus]")
self.ctrl_bus.clear()
self.addr_bus.clear()
print(f"\n{'='*55}")
print(f"Opération terminée : {data} a été écrit à l'adresse {addr}")
print(f"{'='*55}")
# ===== Programme principal : exécuter la démo =====
if __name__ == "__main__":
print("=" * 60)
print(Simulation d'interaction de bus — EXEMPLE Démonstration des principes d'organisation des ordinateurs)
print("=" * 60)
print()
# 1. Initialiser le bus
print("[Initialisation du système] Bus d'adresse, bus de données, bus de contrôle et module mémoire créés")
addr_bus = AddressBus()
data_bus = DataBus()
ctrl_bus = ControlBus()
memory = SimpleMemory()
print()
# 2. Afficher l'état initial de la mémoire
print("[État initial de la mémoire] Aperçu des données aux adresses clés :")
for addr in [50, 51, 52, 53, 54, 55, 100, 200]:
ch = chr(memory.data[addr]) if 32 <= memory.data[addr] < 127 else '?'
print(f" {addr} (0x{addr:04X}): {memory.data[addr]:3d} (0x{memory.data[addr]:02X}) '{ch}'")
print()
3. Initialiser le CPU
cpu = CPU(addr_bus, data_bus, ctrl_bus, memory)
# 4. Démo : Lecture depuis la mémoire
print("\n" + "▼" * 60)
print(Démo 1 : Lire depuis l'adresse mémoire 100)
print("▼" * 60)
val1 = cpu.memory_read(100)
print("\n" + "▼" * 60)
print(Démo 2 : Lire les données depuis l'adresse mémoire 200)
print("▼" * 60)
val2 = cpumemory(200)
print("\n" + "▼" * 60)
print(Démo 3 : Lire séquentiellement depuis les adresses mémoire 50-100 pour assembler les caractères (EXEMPLE))
print("▼" * 60)
chars = []
for addr in range(50, 56):
val = cpu.memory_read(addr)
chars.append(chr(val))
print(f"\n"Chaîne assemblée : {''.join(chars)}")
# 5. Démo : Écriture de données en mémoire
print("\n" + "▼" * 60)
print("Démo 4 : Écrire la donnée 77 à l'adresse mémoire 10")
print("▼" * 60)
cpu.memory_write(10, 77)
# 6. Vérifier le résultat de l'écriture
print("\n" + "▼" * 60)
print("Démo 5 : Vérifier l'écriture — relire les données depuis l'adresse 10")
print("▼" * 60)
val3 = cpu.memory_read(10)
print(f"\nVérification : écriture de 77, lecture de {val3}, {'succès' if val3 == 77 else 'échec'})
print("\n" + "=" * 60)
print(" Toutes les démonstrations sont terminées !")
print("=" * 60)
Largeur du bus et performances réelles
La largeur du bus d'adresses détermine « la quantité de mémoire qu'il peut gérer »
Chaque ligne du bus d'adresses transmet un bit binaire. N lignes d'adresses peuvent représenter 2^N adresses différentes.
| Largeur du bus d'adresses | Espace adressable | Processeur typique |
|---|---|---|
| 16 bits | 2^16 = 64 KB | Intel 8086 (1978) |
| 20 bits | 2^20 = 1 MB | Intel 8088 (IBM PC, 1981) |
| 24 bits | 2^24 = 16 MB | Intel 80286 (1982) |
| 32 bits | 2^32 = 4 GB | Intel 80386 (1985) |
| 64 bits | 2^64 ≈ 16 EB | Processeurs x86-64 modernes |
Remarque : les processeurs 64 bits modernes ont généralement moins de 64 lignes d’adresse réelles (par ex., 48), car 2^64 octets dépassent de loin les besoins actuels en mémoire physique. 48 lignes d’adresse peuvent déjà adresser 256 TB, ce qui suffit pour l’usage actuel.
La largeur du bus de données détermine « combien de données peuvent être transférées en une seule fois »
Un bus de données 8 bits transfère 1 octet à la fois, tandis qu’un bus de données 64 bits transfère 8 octets à la fois. C’est pourquoi, pour une même tâche, les systèmes 64 bits sont souvent plus rapides que les systèmes 32 bits — la quantité de données transférées par opération est doublée.
Types de signaux du bus de contrôle
Le bus de contrôle n’est pas aussi uniforme que les bus d’adresses et de données. Il s’agit d’un ensemble de nombreux types de lignes de signal, notamment :
- MEM_READ / MEM_WRITE: signaux de validation de lecture/écriture mémoire
- IO_READ / IO_WRITE: signaux de lecture/écriture de port d'E/S
- INTERRUPT: signal de demande d'interruption — le moyen utilisé par les périphériques externes pour informer le CPU
- CLOCK: signal d'horloge — le « battement de cœur » qui pousse tout le système à fonctionner de manière synchrone
- RESET: signal de réinitialisation — ramène le CPU à son état initial
Résumé et vérification
Résumé en une phrase :Le bus d'adresses a pour rôle « où aller », le bus de données a pour rôle « quoi transmettre », le bus de contrôle a pour rôle « quoi faire » — les trois bus ont chacun leur rôle et accomplissent ensemble chaque transmission de données.
questions d'auto-évaluation
- Lorsque le CPU veut lire une donnée depuis la mémoire, qui place l'information sur le bus d'adresses ? Et qui place l'information sur le bus de données ?
- Si le bus d'adresses d'un ordinateur ne possède que 16 lignes, quelle est la quantité maximale de mémoire qu'il peut gérer ?
- Quelle est la plus grande différence entre le bus de contrôle et le bus d'adresses et de données ? (Indice : réfléchissez à la « composition » du bus de contrôle.)
Réponse de référence: 1. L'adresse est placée par le CPU, et la donnée est placée par la mémoire. 2. 2^16 = 65536 bytes = 64KB. 3. Les bus d'adresses et de données transmettent des signaux numériques uniformes (valeurs d'adresse/valeurs de données), tandis que le bus de contrôle est un ensemble de lignes de signal discrètes distinctes, chacune ayant sa propre fonction indépendante.
autres extensions