De la porte au CPU

Pourquoi regarder à l'intérieur du processeur ?

Supposons qu'un programme calcule 2 + 3 avant d'afficher un résultat. JavaScript nous épargne les détails, mais la machine doit finir par effectuer une opération avec des bits. Votre code JS n'est pas exécuté tel quel : le moteur (V8 dans Node et Chrome) l'interprète ou le compile vers des instructions machine simplifiées du type « additionne R2 et R3, range dans R1 ». Nous suivons ici cette version simplifiée : ce n'est pas une description exacte de toutes les étapes que V8 choisit pour chaque expression.

Objectifs

À la fin de cette leçon, vous saurez :

• expliquer comment des transistors deviennent des portes, puis des circuits ;
• décrire un additionneur complet et le rôle de l'ALU ;
• expliquer registres, horloge et cycle fetch-decode-execute en une phrase chacun ;
• relier ce cycle au schéma « programme → processus → CPU/RAM » du chapitre 2.

🔗 Pour vous rafraîchir la mémoire : portes logiques · du programme au processus

Du transistor à la porte

Un transistor est un interrupteur commandé électriquement : selon la tension appliquée, il laisse ou bloque le passage du courant dans une partie du circuit. En combinant des transistors, on construit des portes logiques. Le nombre exact de transistors et leur câblage dépendent de la technologie ; retenez la chaîne :

tension (0/1)
  ↓
transistors (interrupteurs)
  ↓
portes (AND/OR/NOT)
  ↓
circuits (additionneurs, multiplexeurs, mémoire)
  ↓
CPU complet

Chaque étage ne parle qu'en 0/1 à l'étage suivant. C'est ce qui rend l'informatique constructible : on empile une abstraction à la fois.

Additionneur complet et ALU

La leçon précédente a posé le demi-additionneur (2 entrées). Un additionneur complet ajoute la retenue entrante — 3 entrées, 2 sorties :

A ──→┐
B ──→│ additionneur complet ──→ somme
retenue_in ──→                ──→ retenue_out

Par exemple, 2 s'écrit 0010 et 3 s'écrit 0011. Posons l'addition en colonnes, comme à l'école, avec la retenue au-dessus :

retenue :  0 0 1 0
  2       0 0 1 0
+ 3       0 0 1 1
= 5       0 1 0 1

De droite à gauche : 0+1=1, puis 1+1=0 retenue 1, puis 0+0+retenue 1=1, puis 0+0=0. Résultat : 0101, soit 5. Un additionneur complet traite justement une colonne et sa retenue entrante. Plusieurs additionneurs réunis permettent d'additionner des nombres à plusieurs bits. Sous le capot, un additionneur complet combine deux demi-additionneurs (vus en leçon précédente) et une porte OR pour fusionner les retenues.

Le CPU contient aussi des circuits qui comparent, soustraient ou appliquent des opérations logiques. On appelle généralement ALU (Arithmetic Logic Unit) l'ensemble chargé de ces opérations. Voilà à quoi servent les portes de la leçon précédente : elles constituent des pièces de circuits capables de produire un résultat exploitable par un programme.

Registres, RAM et horloge

Le CPU utilise des registres — de petites cases très rapides à l'intérieur du processeur — pour garder les valeurs qu'une instruction manipule. Il échange aussi avec la mémoire, souvent par l'intermédiaire de caches. Le nombre et la taille des registres dépendent de l'architecture :

• PC (Program Counter) : adresse de la prochaine instruction à exécuter ;
• registres généraux, que notre modèle appellera R1, R2, R3 : opérandes et résultats temporaires.

La RAM garde notamment le code et les données du processus pendant son exécution. Les registres gardent les quelques valeurs nécessaires immédiatement. Dans notre exemple, R2 peut contenir 2 et R3 contenir 3 ; l'addition place 5 dans R1.

Une horloge donne le tempo : pensez métronome — à chaque top, tous les circuits synchrones avancent d'un cran ensemble. (Un top ne vaut pas forcément une instruction : les processeurs modernes chevauchent et réordonnent le travail. Pour comprendre le principe, nous suivons une instruction à la fois.)

Le cycle fetch-decode-execute

Chaque instruction machine suit la même boucle, indéfiniment :

1. FETCH    obtenir l'instruction désignée par PC depuis la mémoire (souvent via un cache)
2. DECODE   reconnaître l'opération et ses opérandes : par exemple "additionne R2 et R3"
3. EXECUTE  faire calculer l'ALU, puis rendre le résultat disponible dans R1
4. recommencer

Exemple concret — R1 = R2 + R3 :

R2 = 2, R3 = 3
PC désigne une instruction d'addition
         ↓ fetch et decode
Le CPU reconnaît "additionner R2 et R3, ranger dans R1"
         ↓ execute
L'ALU produit 5 ; R1 reçoit 5

Ce modèle donne le fil conducteur. Une vraie architecture exécute des instructions plus variées et optimise leur traitement, mais le lien reste le même : des instructions pilotent des circuits qui lisent, calculent et écrivent des valeurs.

Relisez maintenant le schéma du chapitre 2 avec des yeux neufs :

disque (programme, octets) → mémoire (processus) → CPU (instructions, registres, ALU)

Quand vous lancerez node bonjour.js (exécuter un fichier JavaScript nommé bonjour.js — vous écrirez les vôtres au chapitre 4), le système charge le programme Node.js en mémoire et lui donne du temps CPU. Node lit votre fichier JavaScript ; son moteur interprète ou compile le code selon les cas. Lorsqu'il faut écrire sur la sortie du terminal, Node passe finalement par le système d'exploitation. À chaque étape, le CPU exécute des instructions machine, même si votre code source n'est pas lui-même une suite directe de ces instructions.

Exercice

1. Ordonnez : transistors, portes, additionneur complet, ALU, CPU.
2. Que désigne PC dans notre modèle ? Où se trouvent les valeurs 2 et 3 au moment de l'addition ?
3. Pourquoi le CPU calcule-t-il dans ses registres plutôt que directement en RAM ?
4. Décrivez en 4 lignes le cycle fetch-decode-execute pour une instruction "charge R1 depuis l'adresse 0x100" (0x100 = 256 en décimal, une simple adresse mémoire).
5. Dans le modèle ci-dessus, que doit faire le CPU pour afficher 5 après l'avoir calculé ? Le résultat dans R1 apparaît-il automatiquement à l'écran ?

Résumé

• Transistors → portes → circuits → ALU → CPU : empilement d'abstractions en 0/1.
• Registres = petites cases rapides internes ; RAM = mémoire du processus ; horloge = rythme des circuits synchrones.
• Toute instruction = FETCH (ramène), DECODE (comprend), EXECUTE (agit via ALU), en boucle.
• Le schéma "programme → processus → CPU/RAM" du chapitre 2 est ce cycle, répété à grande vitesse.

FETCH : obtenir l'instruction désignée par PC ("LOAD R1, [0x100]")
DECODE : décoder = "charge", cible R1, source mémoire 0x100
EXECUTE : obtenir la valeur de l'adresse 0x100, la placer dans R1
→ cycle suivant