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 busFonctionnalitésSens de transfertanalogie avec la vie
Bus d'adressesL'adresse mémoire à laquelle accéder pour la transmissionCPU → Mémoire (unidirectionnel)Le « numéro de maison » sur le bordereau de livraison — indiquant au destinataire « Je cherche cette adresse »
Bus de donnéesTransmettre le contenu réel des donnéesbidirectionnelLe « colis » entre les mains du livreur — l'objet lui-même, qui peut être envoyé ou reçu
Bus de contrôleTransmettre des signaux de contrôle tels que lecture/écriture et interruptionsCPU ↔ 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

  1. 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.
  2. 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.
  3. 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.
  4. 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'adressesEspace adressableProcesseur typique
16 bits2^16 = 64 KBIntel 8086 (1978)
20 bits2^20 = 1 MBIntel 8088 (IBM PC, 1981)
24 bits2^24 = 16 MBIntel 80286 (1982)
32 bits2^32 = 4 GBIntel 80386 (1985)
64 bits2^64 ≈ 16 EBProcesseurs 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

  1. 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 ?
  2. 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 ?
  3. 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