← Retour au blogArchitecture de processeur

Visualiser le cycle fetch–decode–execute dans un simulateur

Avancez pas à pas dans un CPU pédagogique transparent, suivez chaque transfert de registre et distinguez les phases d'une instruction, les cycles d'horloge et les pipelines des processeurs modernes.

DennyDenny
10 min de lecture
Chalkboard feature illustration for “Visualiser le cycle fetch–decode–execute dans un simulateur”

En bref : fetch–decode–execute est une séquence conceptuelle, et non la promesse que chaque instruction prend exactement trois cycles d’horloge. Dans un CPU multicycle transparent, le fetch sélectionne et lit une instruction, le decode interprète ses champs et prépare les opérandes, puis l’execute effectue l’opération et valide l’état architectural. L’exercice de simulation le plus utile consiste à prédire chaque transfert de registre avant d’avancer, puis à expliquer chaque changement observé à partir d’une micro-opération explicite.

Un schéma de CPU devient beaucoup plus facile à comprendre lorsqu’on le traite comme une suite de changements d’état plutôt que comme une page de boîtes et de fils. Un simulateur permet de faire une pause après chaque front d’horloge et de demander :

  • Quel registre a été autorisé à se charger ?
  • Quelle source a piloté chaque bus ?
  • Quels signaux de contrôle étaient actifs ?
  • Quelle valeur a changé, et pourquoi ?
  • Quelle adresse le compteur ordinal sélectionnera-t-il ensuite ?

Cette étude de cas utilise un processeur pédagogique volontairement petit, multicycle et adressé par mots. Elle ne décrit ni x86, ni Arm, ni RISC-V, ni tous les détails internes du modèle DigiSim. Son but est d’établir une méthode de suivi applicable au Séquenceur d’instructions ou à un CPU que vous construisez vous-même.

Pour une présentation de l’architecture complète — notamment les caches, les instructions de longueur variable, le pipeline, la spéculation et les différences d’ISA — lisez l’analyse approfondie fetch–decode–execute.

Le chemin de données pédagogique

Notre trace suppose les blocs visibles suivants :

BlocRôle dans ce modèle
Compteur ordinal (PC)Contient l’adresse-mot utilisée pour le prochain fetch séquentiel
Registre d’adresse mémoire (MAR)Contient une adresse pendant l’opération mémoire
Registre de données mémoire (MDR)Contient un mot renvoyé par la mémoire ou préparé pour une écriture
Registre d’instruction (IR)Conserve l’instruction courante pendant son décodage et son exécution
Fichier de registresContient les opérandes et résultats visibles par le programmeur
ALUEffectue les opérations arithmétiques, logiques et les comparaisons
Registre d’indicateursConserve éventuellement des états comme zéro, retenue, signe et débordement
Séquenceur de contrôleSélectionne les sources, destinations, opération de l’ALU et intention mémoire de chaque micro-étape

Ces registres constituent une décomposition pédagogique. Une implémentation réelle peut les combiner, les renommer, les dupliquer, les mettre en pipeline ou les supprimer. Par exemple, un processeur peut conserver plusieurs instructions récupérées dans des files plutôt que dans un seul registre d’instruction, et une interface mémoire peut conserver les requêtes dans un état de protocole plutôt que dans un seul MAR.

Définir le modèle avant de le suivre

La trace n’a de sens que si ses conventions sont écrites. Nous supposerons que :

  • la mémoire est adressée par mots ;
  • chaque instruction occupe un mot ;
  • l’adresse suivante normale est donc PC + 1 ;
  • les données lues en mémoire sont capturées lors d’une micro-étape ultérieure ;
  • les écritures de registres ont lieu sur le front d’horloge actif lorsque leur validation de chargement est active ;
  • le fichier de registres de l’exemple possède deux ports de lecture et un port d’écriture ;
  • les instructions ne mettent à jour les indicateurs que lorsque leur définition le prévoit.

Les machines adressées par octets ou à instructions de longueur variable utilisent un incrément différent du PC. Une mémoire plus rapide peut regrouper des micro-étapes ; une mémoire plus lente peut insérer des états d’attente. Ce sont des choix de conception, pas des contradictions.

Le fetch sous forme de micro-opérations explicites

Un fetch en trois étapes peut être :

F0: MAR <- PC
F1: MDR <- MEM[MAR],  PC <- PC + 1
F2: IR  <- MDR

F0 : sélectionner l’adresse de l’instruction

Le PC pilote le chemin vers le MAR et MAR_LOAD est activé. Après le front :

MARnew=PColdMAR_{new}=PC_{old}

Rien n’oblige le PC à changer pendant cette micro-étape.

F1 : lire la mémoire et préparer l’adresse de continuation

La mémoire renvoie le mot sélectionné par le MAR. Le MDR le capture, tandis que l’incrémenteur du PC prépare l’adresse du mot séquentiel suivant :

MDRnew=MEM[MAR]MDR_{new}=MEM[MAR] PCnew=PCold+1PC_{new}=PC_{old}+1

Ces transferts peuvent se produire ensemble puisqu’ils écrivent dans des registres différents et utilisent des ressources distinctes du chemin de données dans ce modèle.

F2 : conserver l’instruction

L’IR capture le MDR :

IRnew=MDRIR_{new}=MDR

Le chemin de données mémoire est désormais libre pour un chargement ou un stockage ultérieur, tandis que les bits de l’instruction restent stables pour le décodage.

Cette séquence suppose que le résultat mémoire est valide en F1. Une conception fondée sur une poignée de main resterait dans un état d’attente jusqu’à l’arrivée de READY ou d’une réponse équivalente.

Le décodage ne se limite pas à nommer un opcode

Le décodage établit le sens de l’instruction selon l’ISA pédagogique :

  1. identifier le format de l’instruction ;
  2. déterminer si l’encodage est légal ;
  3. extraire les index de registres ou la valeur immédiate ;
  4. sélectionner les opérandes sources ;
  5. choisir une fonction de l’ALU ou une opération mémoire ;
  6. déterminer quel état architectural peut être mis à jour.

Un format d’instruction peut contenir :

register form:  opcode | source A | source B | destination
immediate form: opcode | destination | immediate

Les positions et largeurs des champs dépendent de l’ISA. Ne transposez pas les noms de champs d’un format à l’autre sans vérifier d’abord l’opcode. Le guide du registre d’instruction et du décodage explique plus en détail les formats de longueur fixe et variable.

Dans ce petit processeur, le décodage peut être combinatoire dès que l’IR est chargé. Une « phase de décodage » ne signifie pas nécessairement un cycle d’horloge dédié : elle désigne le travail qui transforme les bits encodés en intention d’opérandes et de contrôle.

Exécuter et valider

L’exécution dépend de la classe de l’instruction.

Arithmétique entre registres

Pour :

ADD R2, R0, R1

le travail logique est :

A <- REG[R0]
B <- REG[R1]
R <- A + B
REG[R2] <- R
FLAGS <- status(R, carries)

Avec deux ports de lecture combinatoires, les opérandes peuvent atteindre l’ALU en une micro-étape et la destination capturer le résultat au front suivant. Un CPU à bus unique peut nécessiter des transferts distincts vers des registres d’opérandes temporaires.

Chargement immédiat

Pour :

LDI R0, 5

le décodage extrait le champ immédiat, l’étend selon la définition de l’instruction et l’achemine vers le port d’écriture de la destination :

REG[0]new=5REG[0]_{new}=5

Il faut spécifier si l’immédiat est étendu par zéros ou par le signe. Les mêmes bits bruts peuvent représenter des valeurs différentes selon l’une ou l’autre règle.

Opération mémoire

Un chargement ou un stockage peut nécessiter :

  1. le calcul de l’adresse effective ;
  2. la demande mémoire ;
  3. l’attente de la réponse ;
  4. la capture des données ou la fin de l’écriture ;
  5. l’écriture éventuelle dans un registre.

C’est pourquoi « execute » s’étend souvent sur plusieurs cycles dans un CPU multicycle.

Branchement

Un branchement conditionnel calcule ou obtient :

  • une condition de branchement ;
  • une adresse cible ;
  • une adresse de continuation.

Un multiplexeur sélectionne ensuite la prochaine valeur du PC. Si le branchement n’est pas pris, le PC incrémenté est conservé. S’il est pris :

PCnew=targetPC_{new}=target

Les indicateurs sont une source possible de condition. Base RISC-V compare plutôt les registres dans ses instructions de branchement. Le guide du compteur ordinal présente ces sources de mise à jour.

Programme étudié : charger, charger, additionner

Utilisez ce programme abstrait :

Adresse-motInstructionSignification
0LDI R0, 5placer 5 dans R0
1LDI R1, 3placer 3 dans R1
2ADD R2, R0, R1placer R0 + R1 dans R2
3HALTne plus accepter de travail d’instruction

L’encodage binaire exact dépend du modèle ou du CPU choisi. Écrivez sa table d’opcodes à côté de la trace au lieu de supposer les valeurs hexadécimales d’une autre ISA pédagogique.

État initial

Supposons que le reset établisse :

PC = 0
R0 = 0
R1 = 0
R2 = 0
controller = F0

Ne supposez pas que toute la mémoire ou tous les registres sont remis à zéro si le reset ou l’initialisation ne le prévoit pas explicitement.

Trace

ÉtapeMicro-opérationÉtat important après le front
1MAR <- PCMAR=0
2MDR <- MEM[MAR], PC <- PC+1MDR=LDI R0,5, PC=1
3IR <- MDRIR=LDI R0,5
4écriture immédiate d’exécutionR0=5
5MAR <- PCMAR=1
6MDR <- MEM[MAR], PC <- PC+1MDR=LDI R1,3, PC=2
7IR <- MDRIR=LDI R1,3
8écriture immédiate d’exécutionR1=3
9MAR <- PCMAR=2
10MDR <- MEM[MAR], PC <- PC+1MDR=ADD R2,R0,R1, PC=3
11IR <- MDRIR=ADD R2,R0,R1
12écriture ALU d’exécutionR2=8 ; indicateurs mis à jour si prévu

Ce programme contient trois instructions mais douze micro-étapes illustrées. Appeler chaque instruction un « cycle » masquerait la différence entre nombre d’instructions, micro-étapes et cycles d’horloge.

Que faut-il observer dans le simulateur ?

À chaque cycle d’horloge, notez :

Signal ou étatQuestion
état du contrôleurQuelle micro-opération est prévue ?
PCDésigne-t-il le mot suivant correct ?
MARQuelle adresse mémoire reste stable ?
MDRQuel mot mémoire a été capturé ?
IRQuelle instruction reste active ?
validations des sourcesLa source prévue exactement est-elle sélectionnée ?
validations de chargementQuels registres changeront sur ce front ?
opération de l’ALUCorrespond-elle à l’instruction décodée ?
adresse/donnée d’écritureLa bonne destination reçoit-elle la bonne valeur ?
indicateursSont-ils mis à jour, conservés ou sans importance pour cette instruction ?

Une trace fiable donne une cause explicite à chaque changement d’état. Si deux sources sont activées sur un bus partagé modélisé, ou si un registre change sans validation de chargement, arrêtez-vous et diagnostiquez la logique de contrôle.

Une meilleure procédure de laboratoire

Passage 1 : prédire

Avant d’appuyer sur Step :

  1. écrivez l’état courant du contrôleur ;
  2. listez les signaux de contrôle actifs ;
  3. calculez la prochaine valeur de chaque registre susceptible de se charger ;
  4. identifiez les registres qui doivent conserver leur valeur.

Passage 2 : observer

Avancez d’un front et comparez les valeurs réelles à la prédiction. Notez la première divergence au lieu de poursuivre avec un état déjà corrompu.

Passage 3 : expliquer

Pour chaque écart, classez-le :

  • encodage d’instruction incorrect ;
  • sélection de source erronée ;
  • destination ou validation de chargement incorrecte ;
  • fonction d’ALU incorrecte ;
  • différence de reset ou d’initialisation ;
  • mise à jour du PC décalée d’une unité ;
  • différence de timing de réponse mémoire ;
  • erreur de condition ou de cible de branchement.

Passage 4 : modifier une seule chose

Remplacez ADD par SUB, modifiez un immédiat ou changez un registre de destination. Prédisez exactement quelles micro-étapes et quelles valeurs doivent différer. Un bon modèle architectural fait produire aux changements locaux du programme des modifications de trace explicables.

Vérifier au-delà d’un seul programme

La trace à trois instructions est un exemple détaillé, pas une vérification suffisante du CPU. Un plan de test utile comprend :

  • chaque opcode légal ;
  • des index de registres et des immédiats légaux représentatifs ;
  • des encodages illégaux ou réservés ;
  • des cas limites arithmétiques ;
  • des chargements/stockages aux limites d’adresse ;
  • des branchements pris et non pris ;
  • le comportement de la cible et de la continuation d’un branchement ;
  • un reset depuis plusieurs états du contrôleur ;
  • le comportement d’arrêt ou d’inactivité ;
  • les états d’attente si la mémoire peut ralentir ;
  • des invariants de contrôle comme une source de bus et une destination d’écriture intentionnelle uniques.

Pour chaque instruction, définissez son résultat architectural indépendamment des micro-étapes. Vérifiez ensuite que l’état visible final correspond, même si le séquencement interne change.

Ce que ce modèle ne prétend pas faire

Les processeurs modernes ne récupèrent généralement pas une instruction, ne la terminent pas complètement, puis ne commencent pas la suivante. Ils peuvent :

  • récupérer plusieurs octets ou instructions à la fois ;
  • prédire le flot de contrôle futur ;
  • décoder en opérations internes ;
  • faire se chevaucher de nombreuses instructions ;
  • exécuter des opérations indépendantes dans le désordre ;
  • attendre les caches tandis qu’un autre travail progresse ;
  • valider les résultats dans l’ordre architectural.

Fetch–decode–execute reste un modèle causal précieux, mais une implémentation haute performance divise et fait se chevaucher ces responsabilités. « Trois phases » n’est pas une équation de performance à trois cycles.

La simulation ne démontre pas non plus le timing physique. Un modèle fonctionnel vérifie les valeurs et le séquencement. La fréquence maximale, la fermeture setup/hold, le skew d’horloge et les délais routés relèvent de l’implémentation cible et de ses outils de timing.

Utilisation en classe

Une activité concise de 30 minutes :

  1. donnez aux étudiants la table des instructions et l’état initial ;
  2. suivez ensemble le premier LDI ;
  3. demandez aux binômes de prédire le deuxième LDI ;
  4. faites suivre l’ADD à chaque binôme et expliquer chaque validation ;
  5. remplacez ADD par SUB et comparez uniquement les signaux affectés ;
  6. terminez par un branchement pris et un branchement non pris.

Évaluez la trace du raisonnement, pas seulement la valeur finale. Un étudiant capable d’expliquer pourquoi le PC, l’IR, les opérandes sources et la destination ont changé a appris davantage qu’un étudiant qui a obtenu R2=8 par essais et erreurs.

Pour aller plus loin

Ouvrez le Séquenceur d’instructions, identifiez ses registres réels et son encodage d’instruction, puis adaptez le tableau de trace à ce que le modèle expose. Considérez les libellés et le comportement du modèle comme faisant autorité pour ce circuit.

Étudiez ensuite séparément les composants :

L’exercice est terminé lorsque vous pouvez faire une pause sur n’importe quel front et prédire chaque changement d’état suivant avant que le simulateur ne le révèle.

Transformez l’idée en un circuit fonctionnel.