Qu'est-ce que l'architecture Von Neumann en NSI ?

C'est un modèle d'ordinateur où les instructions et les données sont stockées dans la même mémoire. Le processeur lit les instructions une par une, les décode et les exécute via le cycle fetch-decode-execute.

Quels sont les composants principaux de l'architecture Von Neumann ?

Le processeur (avec l'UAL et les registres), la mémoire, les bus de communication et les périphériques d'entrée/sortie. Le processeur et la mémoire échangent via un bus unique.

Comment simuler l'architecture Von Neumann en Python ?

On crée une classe Memoire (tableau de cases) et une classe Processeur (avec registres PC, IR, ACC). On écrit un programme sous forme de liste d'instructions, on le charge en mémoire, puis on exécute une boucle qui lit, décode et exécute chaque instruction.

Qu'est-ce que le cycle fetch-decode-execute ?

C'est le cycle d'exécution d'une instruction : fetch (récupérer l'instruction en mémoire à l'adresse PC), decode (déterminer l'opération à effectuer), execute (réaliser l'opération et mettre à jour les registres ou la mémoire).

Pourquoi l'architecture Von Neumann est-elle importante pour le bac NSI ?

Elle fait partie du programme de Terminale NSI. Comprendre ce modèle aide à expliquer le fonctionnement d'un ordinateur, les limites des machines et la programmation bas niveau. Des questions peuvent porter sur le rôle des registres ou sur la simulation d'un programme simple.

Architecture Von Neumann en Python : exemples expliqués (NSI)

Tu as déjà entendu parler du processeur et de la mémoire, mais est-ce que tu sais vraiment comment ils discutent entre eux ? En NSI, l'architecture Von Neumann est un modèle fondamental qui explique comment un ordinateur exécute un programme. Et bonne nouvelle : tu peux la coder toi-même en Python avec quelques lignes de code ! Dans cet article, on va construire ensemble un mini-simulateur pour comprendre le cycle fetch-decode-execute, manipuler le processeur et la mémoire, et voir comment tout s'emboîte. Prêt ? C'est parti.

Qu'est-ce que l'architecture Von Neumann ?

L'architecture Von Neumann, proposée par le mathématicien John von Neumann en 1945, décrit un ordinateur comme un ensemble de composants qui communiquent via un bus unique. Le principe clé : les instructions et les données sont stockées dans la même mémoire. C'est ce qu'on appelle le programme enregistré.

Les composants essentiels

L'unité centrale de traitement (CPU ou processeur) : elle exécute les instructions. Elle contient l'unité arithmétique et logique (UAL) et les registres.
La mémoire : elle stocke à la fois le programme (les instructions) et les données. Chaque case mémoire a une adresse.
Les bus : ce sont les autoroutes qui transportent les données, les adresses et les signaux de contrôle entre le processeur et la mémoire.
Les entrées/sorties : clavier, écran, etc., pour communiquer avec l'extérieur.

Dans ce modèle, le processeur lit une instruction, la décode, l'exécute, puis passe à la suivante. C'est le cycle fetch-decode-execute.

Pourquoi c'est important en NSI ?

Comprendre l'architecture Von Neumann t'aide à saisir comment un programme Python devient une suite d'opérations basiques. Cela éclaire des notions comme les variables, les boucles, ou même les limitations des ordinateurs. C'est aussi un point du programme de Terminale NSI.

Simuler l'architecture Von Neumann en Python

On va créer une classe MachineVonNeumann qui possède une mémoire, un processeur avec quelques registres, et qui exécute un petit programme. On utilisera des instructions simples : LOAD, STORE, ADD, SUB, HLT.

Étape 1 : la mémoire

La mémoire est un tableau de cases, chacune pouvant contenir un entier (pour simplifier). On initialise avec des zéros.

class Memoire:
    def __init__(self, taille=256):
        self.cases = [0] * taille

    def lire(self, adresse):
        return self.cases[adresse]

    def ecrire(self, adresse, valeur):
        self.cases[adresse] = valeur

Chaque case a une adresse (indice) et une valeur. C'est exactement le principe de la mémoire vive.

Étape 2 : le processeur et ses registres

Le processeur possède des registres : PC (compteur de programme), IR (registre d'instruction), ACC (accumulateur). Le PC pointe vers la prochaine instruction à exécuter.

class Processeur:
    def __init__(self):
        self.PC = 0      # Program Counter
        self.IR = None   # Instruction Register
        self.ACC = 0     # Accumulateur

    def charger_instruction(self, memoire):
        self.IR = memoire.lire(self.PC)
        self.PC += 1

    def executer(self, memoire):
        # On suppose que l'instruction est un tuple (code, operande)
        code, operande = self.IR
        if code == 'LOAD':
            self.ACC = memoire.lire(operande)
        elif code == 'STORE':
            memoire.ecrire(operande, self.ACC)
        elif code == 'ADD':
            self.ACC += memoire.lire(operande)
        elif code == 'SUB':
            self.ACC -= memoire.lire(operande)
        elif code == 'HLT':
            return False  # Arrêt
        return True

Le processeur lit l'instruction à l'adresse PC, l'incrémente, puis l'exécute. C'est le cycle fetch-decode-execute.

Étape 3 : le programme et la boucle principale

On place un programme en mémoire à partir de l'adresse 0. Par exemple, pour calculer 5 + 3 et stocker le résultat à l'adresse 10 :

programme = [
    ('LOAD', 20),   # charge la valeur à l'adresse 20 dans ACC
    ('ADD', 21),    # ajoute la valeur à l'adresse 21
    ('STORE', 10),  # stocke ACC à l'adresse 10
    ('HLT', None)   # arrêt
]

memoire = Memoire()
# On place le programme à partir de l'adresse 0
for i, instr in enumerate(programme):
    memoire.ecrire(i, instr)
# Données : 5 à l'adresse 20, 3 à l'adresse 21
memoire.ecrire(20, 5)
memoire.ecrire(21, 3)

cpu = Processeur()
en_cours = True
while en_cours:
    cpu.charger_instruction(memoire)
    en_cours = cpu.executer(memoire)

print(memoire.lire(10))  # Affiche 8

Tu viens de simuler un processeur qui exécute un programme stocké en mémoire ! C'est exactement l'architecture Von Neumann.

Cas d'usage concret : multiplier par addition répétée

Imaginons que l'on veuille multiplier 4 par 3 sans instruction de multiplication. On peut utiliser une boucle : ajouter 4 trois fois. Mais notre processeur n'a pas d'instruction de saut conditionnel. On peut ajouter un saut JMP et un JZ (saut si zéro). Voici comment étendre le processeur :

# Ajout dans executer :
elif code == 'JMP':
    self.PC = operande
elif code == 'JZ':
    if self.ACC == 0:
        self.PC = operande

Programme pour multiplier 4 * 3 :

programme = [
    ('LOAD', 20),   # charge 4
    ('STORE', 10),  # résultat = 4
    ('LOAD', 21),   # charge 3 (compteur)
    ('STORE', 22),  # stocke compteur
    ('LOAD', 22),   # charge compteur
    ('JZ', 11),     # si compteur == 0, va à l'adresse 11 (fin)
    ('LOAD', 10),   # charge résultat
    ('ADD', 20),    # ajoute 4
    ('STORE', 10),  # met à jour résultat
    ('LOAD', 22),   # charge compteur
    ('SUB', 23),    # soustrait 1 (à l'adresse 23)
    ('STORE', 22),  # met à jour compteur
    ('JMP', 4),     # retour au début de la boucle
    ('HLT', None)   # fin
]
# Données : 4 à l'adresse 20, 3 à l'adresse 21, 1 à l'adresse 23

Ce programme illustre comment un processeur simple peut réaliser des opérations complexes avec des instructions de base. C'est le fondement de la programmation bas niveau.

Conseils de méthode et lien avec le bac NSI

Pour réussir les questions sur l'architecture Von Neumann au bac, entraîne-toi à :

Décrire le cycle fetch-decode-execute avec tes mots.
Expliquer le rôle des registres PC, IR, ACC.
Écrire un petit programme en assembleur symbolique et le simuler à la main.
Faire le lien avec Python : une boucle while correspond à des sauts conditionnels.

Tu peux t'aider de nos cours NSI et de nos fiches de révision. Pour approfondir Python, consulte la référence Python. Et si tu veux des exercices supplémentaires, jette un œil à Allolycée ou Allobac.

Conclusion

L'architecture Von Neumann n'est pas qu'un concept théorique : tu peux la coder en Python et voir concrètement comment un processeur et une mémoire collaborent. N'hésite pas à modifier le simulateur, ajouter des instructions, ou optimiser le programme. C'est en expérimentant que tu comprendras vraiment. Alors, à ton clavier !