Architecture de Von Neumann
Progression
#Architecture de Von Neumann
À quoi ça sert: simplifier l’architecture en utilisant une mémoire unifiée pour instructions et données. Conséquences: contention sur un bus partagé (atténuée par les caches), et risques de sécurité si l’exécution de données n’est pas interdite (NX). Le cycle fetch–decode–execute décrit l’exécution.
#Schéma (conceptuel)
- Mémoire: instructions + données
- Unité de contrôle: récupère (fetch), décode, exécute
- ALU: opérations arithmétiques/logiques
- Bus: adresse, données, contrôle
#Cycle d’instruction
- PC → mémoire: fetch instruction
- Décodage: déterminer opcode/opérandes
- Exécution: ALU/mémoire/E/S
- Mise à jour du PC
#Pipeline pas à pas
Cycle fetch → decode → execute
Choisissez un scénario pour observer la progression des instructions et les bulles injectées par les aléas (latence, branchement).
Trois instructions qui se nourrissent les unes des autres. Idéal pour visualiser un pipeline fluide sans aléa : chaque cycle introduit une instruction tandis que les précédentes avancent d’un stage.
| Cycle | Fetch | Decode | Execute | Mémoire | Write-back |
|---|---|---|---|---|---|
| 1 | LOAD R1, [R2 + #4] PC place l’adresse de l’instruction sur le bus ; la mémoire renvoie l’opcode LOA… | — | — | — | — |
| 2 | ADD R3, R3, R1 PC → mémoire : on récupère l’opcode ADD | LOAD R1, [R2 + #4] Le décodeur repère un accès mémoire, récupère registre base (R2) et offset imméd… | — | — | — |
| 3 | STORE R3 → [R4] PC lit l’opcode STORE en mémoire | ADD R3, R3, R1 Lecture des opérandes sources (R3, R1) dans le banc de registres | LOAD R1, [R2 + #4] ALU additionne R2 et l’immédiat pour produire l’adresse effective | — | — |
| 4 | — | STORE R3 → [R4] Chargement de R3 comme source, R4 comme base d’adresse | ADD R3, R3, R1 ALU additionne R3 + R1, met à jour les flags | LOAD R1, [R2 + #4] Bus de données lit la valeur située à l’adresse calculée | — |
| 5 | — | — | STORE R3 → [R4] ALU calcule l’adresse de destination (R4 + offset) | ADD R3, R3, R1 Pas d’accès mémoire: on utilise le bypass de résultat | LOAD R1, [R2 + #4] Registre R1 reçoit la donnée ; flags inchangés, PC incrémenté |
| 6 | — | — | — | STORE R3 → [R4] Bus de données écrit R3 vers la mémoire (write-back) | ADD R3, R3, R1 Résultat stocké dans R3, flags conditionnels mis à jour |
| 7 | — | — | — | — | STORE R3 → [R4] Pas d’écriture registre ; PC avance, file store commit |
Pipeline inactif
Aucune instruction ne traverse ce stage durant ce cycle.
- Le résultat du LOAD est transféré directement à l’ADD via forwarding (bypass)
- Le STORE lit la mémoire dans le stage MEM, ce qui libère le bus pour la prochaine instruction
#Exercice : Simulation du cycle d'instruction
Simulez le cycle d'instruction de Von Neumann pour un processeur très simple avec un jeu d'instructions limité.
#Instructions
- Notre processeur fictif a les instructions suivantes :
LOAD addr: Charge la valeur à l'adresseaddrdans l'accumulateur (ACC)ADD addr: Ajoute la valeur à l'adresseaddrà l'accumulateurSTORE addr: Stocke la valeur de l'accumulateur à l'adresseaddrHALT: Arrête l'exécution
- La mémoire est un tableau d'entiers.
- Le programme counter (PC) pointe vers l'instruction courante.
- L'accumulateur (ACC) stocke le résultat des opérations.
#Exemple de programme
1# Programme qui calcule 5 + 3 et stocke le résultat2# Mémoire :3# Adresse 0: LOAD 10 (charger 5 dans ACC)4# Adresse 1: ADD 11 (ajouter 3 à ACC)5# Adresse 2: STORE 12 (stocker le résultat)6# Adresse 3: HALT (arrêter)7# 8# Données :9# Adresse 10: 510# Adresse 11: 311# Adresse 12: 0 (résultat)12 13def simulate_von_neumann():14 # Mémoire (instructions + données)