Le parcours complet d'une instruction
Des bases binaires du cours 1 au système d'E/S du cours précédent, nous avons couvert tout le contenu essentiel des principes d'organisation des ordinateurs. Ce cours va relier ces points de connaissance en une seule ligne, retraçant le parcours complet d'une instruction de sa naissance à son achèvement.
Nous allons implémenter unsimulateur complet d'ordinateur de von Neumann (FullComputer), il comprend : structure de stockage à quatre niveaux (disque dur, mémoire, cache, registres), transfert de données DMA, pipeline à quatre étages recherche-décodage-exécution-écriture en retour, interaction avec le bus, statistiques du taux de succès du cache. Enfin, imprimez un rapport d'exécution complet.
Révision : carte des connaissances des six modules
Avant de commencer la simulation de bout en bout, passons rapidement en revue les concepts essentiels de chacun des six modules de ce cours :
| Module | sujet | Concepts fondamentaux | Mise en œuvre dans ce cours |
|---|---|---|---|
| Module 1 | Représentation binaire et de l'information | Encodage 0/1, conversion de base, complément à deux, nombres à virgule flottante | Les instructions et les données sont toutes deux stockées sous forme binaire en mémoire. |
| Module 2 | Portes logiques et circuits numériques | Portes AND/OR/NOT, Additionneurs, ALU | Les opérations de l'ALU dans l'étape d'exécution sont implémentées par des circuits de portes. |
| Module 3 | Architecture de von Neumann | Cinq composants principaux, programme enregistré, cycle d'instruction | Ce que ce cours simule est une machine de von Neumann complète. |
| Module 4 | Principes du CPU | Registres, PC, IR, pipeline, quatre étages | Les quatre étages de recherche-décodage-exécution-écriture en retour sont simulés. |
| Module 5 | Système de stockage | Hiérarchie mémoire, cache, principe de localité | Disque dur → mémoire → cache → registres, la chaîne complète de stockage à quatre niveaux. |
| Module 6 | Bus et E/S | Bus d'adresses/de données/de contrôle, scrutation/interruption/DMA | Le DMA charge le programme, le bus transfère les données, remplissage de ligne de cache. |
Le cycle de vie complet d'une instruction
Nous utilisons une simple pseudo-instructionADD A, B(additionner les valeurs des registres A et B, stocker le résultat dans A) comme exemple pour retracer son parcours complet :
Étape 1 du parcours : le programme est stocké sur le disque dur
Le programme est initialement stocké sur le disque dur sous forme de fichier. Le disque dur estun stockage persistant, les données ne sont pas perdues après mise hors tension, mais la vitesse de lecture/écriture est la plus lente (niveau milliseconde).
Étape 2 du parcours : le DMA charge le programme en mémoire.
Lorsque vous double-cliquez pour exécuter le programme, le système d'exploitation, viaDMAdéplace le programme du disque dur vers la mémoire. Le contrôleur DMA prend en charge le travail de déplacement des données, et le CPU peut faire d'autres choses pendant ce temps.
Étape 3 du parcours : le CPU récupère une instruction via le bus.
Le CPU place la valeur du compteur de programme (PC) surle bus d'adresses, surle bus de contrôleet émet un signal « lecture ». Après réception du signal, la mémoire place l'instruction à l'adresse correspondante sur lebus de données, et le CPU la lit dans le registre d'instruction (IR).
Étape 4 du parcours : décodage — le contrôleur analyse l’instruction.
Le ADD A, B dans le registre d’instruction est décomposé en trois parties : opcode ADD, opérande destination A, opérande source B. Le contrôleur décide de l’opération suivante en fonction de l’opcode.
Étape 5 du parcours : exécution — l’ALU effectue l’opération.
Le contrôleur envoie des signaux de commande, amenant l’ALU à prendre les valeurs des registres A et B, à effectuer l’opération d’addition et à stocker temporairement le résultat à la sortie de l’ALU.
Étape 6 du parcours : écriture en retour — le résultat est stocké dans les registres via le bus de données
Les résultats de calcul de l’ALU passent parle bus de donnéespour être réécrits dans le registre A. À ce stade, une instruction a terminé son exécution. Le PC est automatiquement incrémenté de 1 pour pointer vers l’instruction suivante.
Démonstration de code : simulation complète de FullComputer.
La classe FullComputer ci-dessous simule entièrement tout le processus décrit ci-dessus. Elle contient plus de 300 lignes de code, couvrant les points de connaissance des six modules de ce cours. Chaque étape affiche des journaux détaillés.
Exemple
FullComputer - Simulateur complet d’ordinateur de von Neumann (exemple de démonstration pédagogique)
Ce programme implémente un ordinateur complet (simplifié) de von Neumann, comprenant :
- Stockage à quatre niveaux : Disque → Mémoire → Cache → Registre
- Contrôleur DMA : déplace automatiquement les programmes du disque dur vers la mémoire
- Trois types de bus : bus d'adresse, bus de données, bus de contrôle.
- fourPhaseExecute: récupération d'instruction (Fetch) → translatecode (Decode) → Execute (Execute) → écriture en retour (WriteBack)
- Système de statistiques : taux de réussite du cache, nombre d'instructions, nombre d'utilisations du bus, temps d'exécution
Jeu d'instructions pris en charge :
LOAD reg value - Charger la valeur immédiate dans le registre
STORE reg addr - Stocker la valeur du registre à l'adresse mémoire
ADD dst src - dst = dst + src
SUB dst src - dst = dst - src
MUL dst src - dst = dst * src
CMP a b - Comparer deux registres, définir les drapeaux
JMP addr - saut inconditionnel
JZ addr - Sauter si le drapeau zéro est vrai
Comment exécuter : python fullcomputer.py
"""
import time
# ============================
# 1. Système de stockage - Structure à quatre couches
# ============================
class Disk:
"""
Disque dur - le stockage persistant de plus bas niveau.
Vitesse la plus lente (niveau milliseconde), capacité la plus grande, les données ne sont pas perdues en cas de coupure de courant.
"""
def __init__(self):
self.sectors = {} # Stockage par secteurs, simulant les secteurs du disque dur
self.read_latency = 5 # Latence de lecture (unité de temps simulée)
self.write_latency = 8 # Latence d'écriture
def load_program(self, program_name):
Charger le programme stocké sur le disque dur. Renvoyer None si le programme n'existe pas.
if program_name in self.sectors:
print(f" [disque dur] trouver la séquence de cours '{program_name}', taille : {len(self.sectors[program_name])} instructions")
return self.sectors[program_name]
print(f[Disque dur] Programme '{program_name}' introuvable !)
return None
def store_program(self, name, program):
"""Stocker le programme sur le disque dur"""
self.sectors[name] = program
print(f" [Disque dur] Séquence de cours '{name}' stockée ({len(program)} instructions) vers le secteur 0x{hash(name) & 0xFFFF:04X}")
class Memory:
"""
Mémoire principale - stockage secondaire.
Vitesse moyenne (niveau nanoseconde), grande capacité, les données sont perdues lorsque l'alimentation est coupée.
Le CPU ne peut accéder directement qu'aux données en mémoire (il ne peut pas accéder directement au disque dur).
"""
def __init__(self, size=65536):
self.size = size # Taille de la mémoire (bytes)
self.cells = {} # Unité de mémoire : la clé est l'adresse, la valeur est la donnée/l'instruction
self.read_count = 0 # Nombre d'opérations de lecture
self.write_count = 0 # Nombre d'opérations d'écriture
def read(self, addr):
Lire les données à l'adresse spécifiée
self.read_count += 1
if addr not in self.cells:
print(f" Avertissement : l'adresse {addr} n'est pas initialisée, retourne 0")
return 0
return self.cells[addr]
def write(self, addr, data):
Écrire les données à l'adresse spécifiée
self.write_count += 1
self.cells[addr] = data
def load_block(self, start_addr, data_block):
"""
Charger un bloc entier de données dans une région d'adresses contiguë de la mémoire.
Pour les scénarios de transfert par lots DMA.
"""
for i, item in enumerate(data_block):
self.cells[start_addr + i] = item
return len(data_block)
class Cache:
"""
Cache (simulation de cache L1) - Stockage de troisième niveau.
Extrêmement rapide (même fréquence que le CPU), plus petite capacité.
Utilisation d'un modèle simple de cache à correspondance directe :
- Chaque ligne de cache stocke : (adresse mémoire, contenu des données)
- Succès de cache : les données sont déjà dans le cache, les renvoyer directement
Défaut de cache : il faut charger depuis la mémoire, remplacer une ligne de cache.
"""
def __init__(self, num_lines=8):
self.num_lines = num_lines
self.lines = {} # Ligne de cache : {cache_line_index: (mem_addr, data)}
self.hit_count = 0
self.miss_count = 0
def read(self, mem_addr, memory):
"""
Lire depuis le cache. En cas de succès (hit), retourner directement ; en cas d'échec (miss), charger depuis la mémoire.
Retour : (data, was_hit)
"""
# Mappage simple : index de ligne de cache = adresse mémoire % nombre de lignes de cache
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:
# Succès du cache
self.hit_count += 1
print(f" [Mise en cache] succès!ligne {line_index}, Adresse {mem_addr}, Données : {cached_data}")
return cached_data, True
# Défaut de cache
self.miss_count += 1
data = memory.read(mem_addr)
self.lines[line_index] = (mem_addr, data)
print(f" [Mise en cache] échec, depuis l'adresse mémoire {mem_addr} ajout des données chargées {data} → Ligne de cache {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:
"""
Fichier de registres - le stockage le plus haut.
Le plus rapide (un cycle d'horloge), la plus petite capacité.
Registres à usage général + registres à usage spécial (PC, IR, MAR, MDR, FLAGS)
"""
def __init__(self):
# Registres à usage général
self.gpr = {'A': 0, 'B': 0, 'C': 0, 'D': 0}
# Registres spécialisés
self.PC = 0 # Compteur de programme : stocke l'adresse de la prochaine instruction
self.IR = None # Registre d'instruction : stocke l'instruction en cours d'exécution
self.MAR = 0 # Registre d'adresse mémoire : stocke l'adresse mémoire à laquelle accéder
self.MDR = 0 # Registre de données mémoire : stocke les données lues depuis la mémoire / à écrire dans la mémoire
# Registre des drapeaux
self.FLAGS = {'Z': False} # Drapeau zéro : indique si le résultat de l'opération précédente est 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. Système de bus - Trois bus
# ============================
class SystemBus:
"""
Bus système - comprend le bus d'adresses, le bus de données, le bus de contrôle.
Fournit une interface unifiée pour le CPU, la mémoire et le DMA.
"""
def __init__(self):
self.address_bus = 0 # Bus d'adresses : adresse en cours de transmission
self.data_bus = 0 # Bus de données : données en cours de transmission
self.control_bus = 'IDLE' # Bus de contrôle : IDLE, READ, WRITE, INTERRUPT, DMA_REQ, DMA_ACK
self.transfer_count = 0 # Compteur de transferts du bus
def cpu_read(self, address, memory, cache):
"""
Le CPU lit les données depuis la mémoire via le bus (à travers le cache).
Processus complet d'interaction avec le bus :
1. Le CPU place l'adresse sur le bus d'adresses
2. Le CPU émet un signal READ sur le bus de contrôle.
3. La mémoire (via la couche de cache) renvoie les données vers le bus de données
4. Le CPU lit les données depuis le bus de données
5. Effacer le bus
"""
self.address_bus = address
self.control_bus = 'READ'
self.transfer_count += 1
print(f[Bus] bus d'adresses ← {address}, bus de contrôle ← READ)
# La mémoire répond via la couche de cache
data, was_hit = cache.read(address, memory)
self.data_bus = data
print(f" [bus] Bus de données ← {data} {'(Succès du cache)' if was_hit else '(vient de la mémoire)'}")
# CPU lit des données
result = self.data_bus
# Libération du bus
self.address_bus = 0
self.data_bus = 0
self.control_bus = 'IDLE'
print(f[Bus] Bus libéré, passage à l'état inactif)
return result
def cpu_write(self, address, data, memory):
"""
Le CPU écrit des données en mémoire via le bus.
"""
self.address_bus = address
self.data_bus = data
self.control_bus = 'WRITE'
self.transfer_count += 1
print(f[Bus] Bus d'adresses ← {address}, Bus de données ← {data}, Bus de contrôle ← WRITE)
memory.write(address, data)
print(f[Bus] Les données {data} ont été écrites à l'adresse mémoire {address})
# Libération du bus
self.address_bus = 0
self.data_bus = 0
self.control_bus = 'IDLE'
print(f[Bus] Bus libéré, passage à l'état inactif)
# ============================
# 3. Contrôleur DMA
# ============================
class DMAController:
"""
Contrôleur DMA - responsable du transfert direct de données entre le disque dur et la mémoire.
Le CPU doit seulement indiquer au DMA : adresse source, adresse de destination, longueur du transfert.
Une fois que le DMA a terminé le transfert, il notifie le CPU via une interruption.
"""
def __init__(self, bus):
self.bus = bus
self.transfer_count = 0 # Nombre de transferts DMA
self.total_bytes = 0 # Total d'octets transférés
def transfer_program(self, disk, program_name, memory, load_addr=0):
"""
Charger le programme du disque dur en mémoire via DMA.
Ceci est une application pratique de la leçon 20 « mode DMA » de ce cours.
"""
print(f"\n {'='*50}")
print(fLe transfert DMA commence : disque dur → mémoire)
print(f" {'='*50}")
print(f[DMA] Source : secteur de disque dur (programme '{program_name}'))
print(f[DMA] Cible : adresse mémoire de début 0x{load_addr:04X})
print(f[DMA] Demande de contrôle du bus...)
# DMA occupe le bus
self.bus.control_bus = 'DMA_REQ'
print(f[DMA] obtient le contrôle du bus (bus de contrôle ← DMA_REQ))
program = disk.load_program(program_name)
if program is None:
print(f[DMA] Erreur : le programme n'existe pas, transfert avorté)
self.bus.control_bus = 'IDLE'
return 0
# Transfert instruction par instruction
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] transmission #{i} : Directive '{instruction}' → Adresse mémoire {addr} (0x{addr:04X})")
# DMA libère le bus et envoie une interruption d'achèvement
self.bus.control_bus = 'DMA_ACK'
print(f" [DMA] transmission terminée ! total {len(program)} directives, {self.total_bytes} transmissions de bus")
print(f[DMA] Libération du contrôle du bus (bus de contrôle ← IDLE))
# L'interruption notifie le CPU
print(f" [DMA] Envoyer un signal d'interruption pour notifier le CPU : chargement du programme terminé")
self.bus.control_bus = 'INTERRUPT'
# Traitement après réception d'une interruption par le CPU
time.sleep(0.001)
print(f[Réponse à l'interruption CPU] Interruption de fin de DMA reçue, le programme est prêt)
self.bus.control_bus = 'IDLE'
return len(program)
def cache_prefetch(self, memory, cache, start_addr, count):
"""
Préchargement DMA : précharger dans le cache les données qui seront bientôt utilisées depuis la mémoire.
Simuler le mécanisme de préchargement matériel d'un CPU moderne.
"""
print(f"\n[Préchargement DMA] Précharger les adresses mémoire {start_addr}~{start_addr+count-1} dans le cache...)
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[DMA Prefetch] Terminé, {count} instructions écrites dans le cache)
# ============================
# 4 ALU - Unité arithmétique
# ============================
class ALU:
"""
Unité arithmétique et logique - effectue toutes les opérations arithmétiques.
Contenu correspondant au deuxième module du cours, comme les additionneurs et les portes logiques.
"""
@staticmethod
def add(a, b):
print(f[ALU] Exécution de l'addition : {a} + {b} = {a + b})
return a + b
@staticmethod
def subtract(a, b):
print(f[ALU] Exécution de la soustraction : {a} - {b} = {a - b})
return a - b
@staticmethod
def mul(a, b):
print(f[ALU] Exécution de la multiplication : {a} * {b} = {a * b})
return a * b
@staticmethod
def cmp(a, b):
result = (a == b)
print(f" [ALU] ExecuteCompare: {a} == {b} ? {'is' if result else 'no'} (Z={1 if result else 0})")
return result
# ============================
# 5. FullComputer - Ordinateur complet
# ============================
class FullComputer:
"""
Simulateur complet d'ordinateur von Neumann.
Composants :
- disk : disque dur (stockage persistant)
- memory : mémoire principale
- cache : cache L1
- registres : groupe de registres (y compris PC, IR, MAR, MDR, FLAGS)
- alu : unité arithmétique et logique
- bus : bus système (adresse + données + contrôle)
- dma : contrôleur DMA
Flux d'exécution :
1. Chargement : le DMA transfère le programme du disque dur à la mémoire.
2. Cycle d'instruction : récupérer → décoder → exécuter → écrire en retour.
3. Générer un rapport d'exécution complet
"""
def __init__(self):
print("=" * 60)
print(FullComputer - ordinateur von Neumann en cours d'initialisation...)
print("=" * 60)
# Système de stockage à quatre niveaux
self.disk = Disk()
self.memory = Memory()
self.cache = Cache(num_lines=8)
self.registers = RegisterFile()
# Unité de calcul
self.alu = ALU()
# Système de bus
self.bus = SystemBus()
# Contrôleur DMA
self.dma = DMAController(self.bus)
# Statistiques
self.instructions_executed = 0
self.clock_cycles = 0
print(Composants prêts : disque dur, mémoire (64KB), cache (L1 à 8 lignes), 4 registres à usage général)
print(Composants prêts : ALU, bus système, contrôleur DMA)
print()
def store_program(self, name, program):
"""Stocker le programme sur le disque dur"""
print(f[Étape 0] Enregistrer le programme '{name}' sur le disque dur)
self.disk.store_program(name, program)
print()
def load_program(self, program_name, load_addr=0):
"""
Charger le programme : transferts DMA du disque dur vers la mémoire.
"""
print(f[Étape 1] DMA charge le programme en mémoire)
size = self.dma.transfer_program(
self.disk, program_name, self.memory, load_addr
)
print()
# Précharger les instructions dans le cache
print(f[Étape 2] Préchauffage du cache : précharger les {min(4, size)} premières instructions)
self.dma.cache_prefetch(self.memory, self.cache, load_addr, min(4, size))
print()
# Définir PC à l'adresse de début du programme
self.registers.PC = load_addr
print(f[Étape 3] Définir PC ← {load_addr} (adresse de début du programme))
print()
def fetch(self):
"""
Étape 1 : Récupération
- Placer la valeur de PC dans MAR
- Envoyer l'adresse via le bus d'adresses
- Envoyer le signal READ via le bus de contrôle
- Récupérer l'instruction depuis le bus de données (via la couche de cache)
- Stocker l'instruction dans IR
- Incrémenter PC
"""
print(f"--- Étape 1 : Récupération de l'instruction (Fetch) ---")
self.clock_cycles += 1
# MAR ← PC
self.registers.MAR = self.registers.PC
print(f" MAR ← PC = {self.registers.PC}")
# Lire la mémoire via le bus (via le cache)
instruction = self.bus.cpu_read(
self.registers.MAR, self.memory, self.cache
)
# MDR ← bus de données, IR ← MDR
self.registers.MDR = instruction
self.registers.IR = instruction
print(f" MDR ← {instruction}, IR ← MDR")
# Incrémentation du PC
old_pc = self.registers.PC
self.registers.PC += 1
print(f" PC ← {old_pc} + 1 = {self.registers.PC}")
return instruction
def decode(self):
"""
⟦⟧Étape : Décodage
- Le contrôleur décode l'instruction dans l'IR
- Séparer l'opcode et l'opérande
- Déterminer les opérations de l'étape d'exécution
"""
print(f--- Étape 2 : Décodage ---)
self.clock_cycles += 1
instruction = self.registers.IR
parts = instruction.split()
opcode = parts[0]
operands = parts[1:] if len(parts) > 1 else []
print(f" Instruction : '{instruction}'")
print(fOpcode : {opcode}, opérandes : {operands})
return opcode, operands
def execute(self, opcode, operands):
"""
Étape 3 : Exécution
- Exécuter l'opération correspondante en fonction de l'opcode
- L'ALU participe aux opérations arithmétiques/logiques
- Peut modifier les registres ou positionner des bits d'indicateur
"""
print(f--- Phase 3 : Exécuter ---)
self.clock_cycles += 1
if opcode == 'LOAD':
# LOAD reg value: Charger la valeur immédiate dans le registre
reg, value = operands[0], int(operands[1])
self.registers.gpr[reg] = value
print(fOpération : chargement immédiat {value} → registre {reg})
print(f" L'ALU ne participe pas (chargement direct)")
elif opcode == 'STORE':
# STORE reg addr: Stocker la valeur du registre en mémoire
reg, addr = operands[0], int(operands[1])
value = self.registers.gpr[reg]
print(fOpération : préparation pour stocker la valeur {value} du registre {reg} à l'adresse mémoire {addr})
# Les données sont prêtes ; l'étape de write-back effectue l'opération d'écriture réelle.
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
# Positionner l'indicateur zéro
self.registers.FLAGS['Z'] = (result == 0)
print(f" Opération : {dst} ← {old_val} + {self.registers.gpr.get(src, src)} = {result}")
print(fIndicateur zéro 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" Opération : {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" Opération : {dst} ← {old_val} * {self.registers.gpr.get(src, src)} = {result}")
elif opcode == 'CMP':
# CMP a b: comparer deux valeurs de registre, positionner le drapeau zéro
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 : saut inconditionnel
target = int(operands[0])
print(fOpération : saut inconditionnel vers l'adresse {target})
old_pc = self.registers.PC
self.registers.PC = target
print(fPC ← {old_pc} → {target} (saut))
elif opcode == 'JZ':
# JZ addr : saut si le drapeau zéro est vrai
target = int(operands[0])
if self.registers.FLAGS['Z']:
print(fOpération : si le drapeau zéro est vrai (Z=1), sauter à l'adresse {target})
self.registers.PC = target
else:
print(fOpération : le drapeau zéro est faux (Z=0), pas de saut, exécution séquentielle)
elif opcode == 'HALT':
# HALT : Arrêt
print(fOpération : instruction Halt, le programme se termine)
return 'HALT'
else:
print(f" Opcode inconnu : {opcode}")
return None
def writeback(self):
"""
Étape 4 : WriteBack
- Si des opérations doivent être réécrites en mémoire (comme STORE), elles sont terminées à cette étape
- Transférer des données via le bus de données
"""
print(f"--- Étape 4 : WriteBack ---")
self.clock_cycles += 1
# Le résultat d'une instruction générale a déjà été écrit dans le registre pendant l'étape d'exécution
# L'instruction STORE doit écrire en mémoire à cette étape
print(fÉtat des registres : {self.registers.gpr})
print(fRegistre des drapeaux : {self.registers.FLAGS})
def writeback_store(self, addr, value):
"""Opération d'écriture en retour de l'instruction STORE — écrire en mémoire via le bus"""
self.bus.cpu_write(addr, value, self.memory)
print(fSTORE terminé : {value} → adresse mémoire {addr})
def run(self):
"""
Exécuter le programme chargé.
Boucler sur la récupération → le décodage → l'exécution → l'écriture en retour jusqu'à la fin du programme.
"""
print("=" * 60)
print(Le programme commence son exécution)
print("=" * 60)
while self.registers.PC < max(self.memory.cells.keys(), default=0) + 1:
# Vérifier si PC est dans la plage valide
if self.registers.PC not in self.memory.cells:
# Le PC dépasse la plage du programme, peut-être à cause d'un saut vers la fin, terminer
print(f"\nLe compteur de programme PC={self.registers.PC} dépasse la plage du programme, l'exécution se termine)
break
self.instructions_executed += 1
print(f"\n{'#' * 55}")
print(f"### Directive #{self.instructions_executed} | PC = {self.registers.PC}")
print(f"{'#' * 55}")
# Récupération de l'instruction
instruction = self.fetch()
# Décodage
opcode, operands = self.decode()
# Exécuter
special = self.execute(opcode, operands)
# Gérer l'instruction HALT
if special == 'HALT':
self.clock_cycles += 1
break
# Écriture en retour
if special and special[0] == 'STORE':
_, reg, addr, value = special
self.writeback_store(int(addr), value)
else:
self.writeback()
# Vérification de sécurité : empêcher les boucles infinies
if self.instructions_executed > 1000:
print("\nAvertissement : plus de 1000 instructions exécutées, arrêt forcé (boucle infinie possible))
break
print(f"\n{'=' * 60}")
print(f" Exécution du programme terminée")
print(f"{'=' * 60}")
def report(self):
"""
Générer un rapport d'exécution complet.
Résumer toutes les statistiques : taux de réussite du cache, nombre d'instructions, cycles d'horloge,
Nombre de transferts sur le bus, nombre de lectures/écritures en mémoire, etc.
"""
print(f"\n{'=' * 65}")
print(fRapport d'exécution FullComputer —— EXEMPLE)
print(f"{'=' * 65}")
print()
# Informations de base
print(f" {'─' * 55}")
print(f" Informations de base")
print(f" {'─' * 55}")
print(fTotal des instructions exécutées : {self.instructions_executed:>6d})
print(fTotal des cycles d'horloge : {self.clock_cycles:>6d} cycles)
if self.instructions_executed > 0:
cpi = self.clock_cycles / self.instructions_executed
print(fCPI moyen (cycles/instruction) : {cpi:>6.2f})
print()
# Performances du cache
print(f" {'─' * 55}")
print(f"Performances du cache (cache L1)")
print(f" {'─' * 55}")
total_access = self.cache.hit_count + self.cache.miss_count
print(f" Succès du cache : {self.cache.hit_count:>6d} fois")
print(f" Défauts du cache : {self.cache.miss_count:>6d} fois")
print(fTotal des accès : {total_access:>6d} fois)
print(fTaux de succès : {self.cache.hit_rate:>6.1f}%)
print(fNombre total de lignes de cache : {self.cache.num_lines:>6d} lignes)
print()
# Accès mémoire
print(f" {'─' * 55}")
print(f" Statistiques d'accès mémoire")
print(f" {'─' * 55}")
print(fOpérations de lecture mémoire : {self.memory.read_count:>6d} fois)
print(fOpération d'écriture mémoire : {self.memory.write_count:>6d} fois)
print(f" Total des visites mémoire : {self.memory.read_count + self.memory.write_count:>6d} fois")
print(fNombre d'adresses mémoire utilisées : {len(self.memory.cells):>6d})
print()
# Statistiques du bus
print(f" {'─' * 55}")
print(f" Statistiques du bus")
print(f" {'─' * 55}")
print(f" Transmissions de bus émises par le CPU : {self.bus.transfer_count:>6d} fois")
print(f" Transmissions de bus émises par le DMA : {self.dma.transfer_count:>6d} fois")
total_bus = self.bus.transfer_count + self.dma.transfer_count
print(fNombre total de transferts sur le bus : {total_bus:>6d} fois)
print()
# État final des registres
print(f" {'─' * 55}")
print(f" État final des registres")
print(f" {'─' * 55}")
print(fRegistres à usage général : {self.registers.gpr})
print(fCompteur de programme PC : {self.registers.PC})
print(fRegistre d'instruction IR : {self.registers.IR})
print(fRegistre de drapeaux FLAGS : {self.registers.FLAGS})
print()
# Vidage des données mémoire (affiche uniquement les données aux adresses valides)
print(f" {'─' * 55}")
print(f" Vidage des données mémoire (affiche uniquement la zone du programme)")
print(f" {'─' * 55}")
if self.memory.cells:
for addr in sorted(self.memory.cells.keys()):
val = self.memory.cells[addr]
print(fAdresse {addr:>4d} (0x{addr:04X}): {val})
else:
print(f" (La mémoire est vide)")
print()
print(f"{'=' * 65}")
print(fFin du rapport. Merci d'avoir utilisé le simulateur EXAMPLE FullComputer !)
print(f"{'=' * 65}")
# ============================
# 6. Programme principal - Démo de bout en bout
# ============================
if __name__ == "__main__":
print()
print("╔" + "═" * 58 + "╗")
print("║" + Le parcours complet d'une instruction — Démo EXAMPLE FullComputer.center(52) + "║")
print("╚" + "═" * 58 + "╝")
print()
# Créer l'ordinateur
computer = FullComputer()
# Définir le programme de démo : calculer (10 + 7) * 2 - 3 = ?
# Utiliser LOAD pour charger la valeur initiale, et ADD/MUL/SUB pour effectuer le calcul
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", # Stocker le résultat à l'adresse mémoire 100
"LOAD B 31", # B = 31 (résultat attendu)
"CMP A B", # Comparer A et B -> devraient être égaux
"JZ 12", # Si égal (Z=1), sauter à HALT
"LOAD D 0", # (non exécuté) D = 0
"HALT", # Arrêt
]
# Étape 1 : Stocker le programme sur le disque dur
computer.store_program("EXAMPLE_DEMO", demo_program)
# Étape 2 : Chargement DMA en mémoire
computer.load_program("EXAMPLE_DEMO", load_addr=0)
# Étape 3 : Exécuter le programme
computer.run()
# Étape 4 : Afficher le rapport d'exécution complet
computer.report()
print(f"\n")
print(fRécapitulatif : Cette démo couvre les six modules de Principes d'organisation des ordinateurs :)
print(fModule 1 (Binaire) : Les instructions et les données sont stockées en mémoire en codage binaire.)
print(fModule 2 (Portes logiques) : les ADD/SUB/MUL dans l'étape d'exécution sont réalisés par les circuits à portes de l'ALU)
print(fModule 3 (von Neumann) : le programme et les données partagent la mémoire, cinq composants principaux fonctionnent ensemble)
print(fModule 4 (Principes du CPU) : récupération par PC → décodage par IR → exécution par ALU → écriture en retour, pipeline complet en quatre étapes.)
print(fModule 5 (Système de stockage) : disque dur → mémoire → cache → registres, hiérarchie de stockage à quatre niveaux)
print(fModule 6 (Bus et E/S) : interaction des trois bus, chargement de programme par DMA, notification d'interruption)
print()
Interprétation du rapport d'exécution
Après avoir exécuté le code ci-dessus, FullComputer produit un rapport d'exécution détaillé. Interprétons les métriques clés :
taux de succès du cache
Le taux de succès du cache indiqué dans le rapport reflète lalocalité temporelleet lalocalité spatialedu programme. Comme notre programme de démonstration est très petit et que le DMA précharge les 4 premières instructions, le taux de succès sera relativement élevé. Dans les programmes réels de grande taille, le taux de succès du cache est généralement supérieur à 90 % — c'est exactement le but du cache.
CPI (cycles d'horloge par instruction)
Dans notre simulation simplifiée, chaque instruction prend 4 cycles d'horloge fixes (récupération-décodage-exécution-écriture en retour), donc le CPI est d'environ 4. Les CPU modernes utilisent le pipeline pour réduire le CPI à près de 1 — c'est-à-dire terminer une instruction par cycle d'horloge.
Nombre de transferts sur le bus
Nombre de transferts sur le bus = transferts initiés par le CPU + transferts initiés par le DMA. Le DMA effectue un grand nombre de transferts pendant la phase de chargement du programme, et le CPU initie au moins un transfert de lecture pendant l'étape de recherche d'instruction de chaque instruction.
Ce que nous avons appris — bilan du cours de six semaines.
Il y a six semaines, nous sommes partis de la question la plus simple : « Pourquoi les ordinateurs ne comprennent-ils que 0 et 1 ? » Aujourd'hui, nous sommes capables de construire un simulateur complet d'ordinateur à partir de zéro. Parcourons à nouveau ce parcours d'apprentissage :
| numéro de semaine | Module | Points clés à retenir |
|---|---|---|
| Semaine 1 | Représentation binaire et de l'information | Nous avons compris pourquoi les ordinateurs utilisent le binaire, comment effectuer une conversion de base, et comment diverses informations (nombres, texte, images) sont encodées en 0 et 1. |
| Semaine 2 | Portes logiques et circuits numériques | Nous avons maîtrisé les trois circuits logiques de base : ET, OU, NON ; compris comment construire des additionneurs et des ALU à l'aide de ceux-ci. |
| Semaine 3 | Architecture de von Neumann | Nous avons compris la répartition des tâches entre les cinq composants principaux (unité arithmétique, unité de contrôle, mémoire, entrée, sortie) et le concept de programme stocké. |
| Semaine 4 | Principes du CPU | Maîtrisé les quatre étapes du cycle d'instruction : recherche, décodage, exécution, écriture en retour, et comment le pipeline améliore l'efficacité. |
| Semaine 5 | Système de stockage | Compris la pyramide de stockage à quatre niveaux, des registres au disque dur, et comment le cache utilise le principe de localité pour accélérer l'accès. |
| Semaine 6 | Bus et E/S | Maîtrisé le travail coopératif des trois bus (adresse/données/contrôle) et les différences d'efficacité entre les trois méthodes d'E/S (scrutation/interruption/DMA). |
De la théorie à la pratique : où aller ensuite.
Ce cours vous a posé une base solide en principes d'organisation des ordinateurs. Si vous souhaitez approfondir, voici quelques orientations recommandées :
- Système d'exploitation: Apprenez comment les systèmes d'exploitation gèrent le CPU, la mémoire, les systèmes de fichiers et les périphériques d'E/S. Les « interruptions », « DMA » et « hiérarchie de mémoire » appris dans ce cours sont des concepts fondamentaux des systèmes d'exploitation.
- Langage assembleur: Interagissez directement avec les instructions du CPU. Après avoir terminé ce cours, le langage assembleur n'est plus un « livre scellé » — vous savez comment chaque instruction d'assemblage est exécutée au niveau matériel.
- nand2tetris: Un célèbre cours en ligne qui vous fait passer d'une simple porte NAND à la construction progressive d'un ordinateur programmable complet. Le contenu de ce cours est hautement complémentaire de ce dernier.
- Architecture des ordinateurs: Approfondissez les techniques avancées de conception de CPU telles que le pipeline, l'exécution superscalaire, l'exécution dans le désordre et la prédiction de branchement.
- système embarqué: Appliquez les connaissances de ce cours aux microcontrôleurs (comme Arduino, STM32), en écrivant des programmes qui manipulent directement les registres et les périphériques.
Résumé et vérification finale
Résumé en une phrase :L'ordinateur n'est pas de la magie — il est une abstraction conçue avec soin, couche par couche, à partir de transistors ouverts/fermés ; on construit progressivement des portes logiques, l'ALU, le CPU, le système mémoire, le bus, et finalement on assemble une machine capable d'exécuter n'importe quelle séquence d'instructions d'un ordinateur d'usage général. Comprendre ces niveaux, c'est vraiment comprendre correctement l'ordinateur.
Questions d'auto-test complètes du cours
- Dans le simulateur FullComputer, lors de l'exécution d'une instruction LOAD, dans quelles étapes le bus d'adresses, le bus de données et le bus de contrôle sont-ils utilisés respectivement ?
- Si le cache de FullComputer n'a que 4 lignes (au lieu de 8), quel impact cela a-t-il sur l'efficacité d'exécution du programme ? Comment ce phénomène est-il appelé en architecture informatique ?
- Dans quels scénarios les systèmes d'exploitation modernes utilisent-ils l'interrogation (polling), les interruptions et le DMA ? Veuillez donner un exemple pour chacun que vous pouvez observer en utilisant un ordinateur au quotidien.
Réponse de référence: 1. Étape de récupération (Fetch) : le bus d'adresses transmet la valeur du PC (adresse de l'instruction), le bus de contrôle envoie un signal READ, et le bus de données renvoie le contenu de l'instruction. 2. Davantage de conflits de cache, taux de réussite plus faible (appelé cache thrashing ou conflict misses). 3. Interrogation (polling) : vérification de progression pendant les mises à jour de firmware sur certains appareils embarqués simples ; Interruption : chaque appui sur une touche du clavier déclenche une interruption ; DMA : copie de gros fichiers, transfert du framebuffer pour le rendu de la carte graphique.
autres extensions