🧠 Le Processeur

Un processeur moderne, c'est une usine à instructions. Ça arrive en flux, ça passe sur un tapis roulant, chaque atelier fait sa part du boulot, et à la fin une resultat sort — en principe celui que vous vouliez.

Entre tout ça : des kilomètres de transistors, des horloges qui tickent à plusieurs milliards de fois par seconde, et suffisamment de fils pour emballer la Terre.

Les registres sont les 16 petits casiers de la banane du processeur. Accès : 1 cycle horloge. Pas de « veuillez patienter ». Pas de « votre fichier est sur le disque réseau ». Juste boum, c'est là.

Notre code assembleur utilise une partie seulement. Voici les stars de la factorielle :

Les flags (EFLAGS / RFLAGS)

Un registre spécial dont chaque bit raconte quelque chose sur la dernière opération :

ALU = Arithmetic Logic Unit. C'est le cœur du réacteur. Elle additionne, soustrait, multiplie, divise, décale, fait du ET/OU/XOR, compare… et met à jour les flags.

Quand notre code fait imulq %rdx, %rax, c'est l'ALU qui tourne — elle prend deux entrées (les registres), les balance dans son circuit de multiplication, et écrit le résultat dans %rax.

# Chaque fois que vous voyez l'une de ces instructions, l'ALU sue :
imulq %rdx, %rax   ; multiplication → ALU en mode bourrin
addl  $1, -12(%rbp) ; addition → ALU en mode cantine
salq  $4, %rax    ; décalage → ALU en mode déménageur
cmpl  %eax, %ebx  ; comparaison → ALU en mode arbitre

Les variantes de l'ALU

Le processeur ne parle pas assembleur. Il parle microcode. Le décodeur est l'interprète attitré : il prend vos instruction x86-64 (qui peuvent faire de 1 à 15 octets — merci l'héritage CISC) et les traduit en une séquence d'opérations microscopiques (micro-ops) que le cœur exécute.

# Ce que vous écrivez :
addl $1, -12(%rbp)

# Ce que le décodeur comprend :
  * charger la valeur à l'adresse rbp-12
  * ajouter 1
  * écrire à l'adresse rbp-12
  * mettre à jour les flags (ZF, SF, OF, CF)

# Soit typiquement 2 à 3 micro-ops.

Pipeline — la chaîne de montage

Une instruction ne passe pas d'un coup dans l'ALU. Elle traverse des étapes — comme dans une chaîne de montage automobile :

Chaque étape prend 1 cycle. Donc une instruction met 5 cycles à passer, mais on en délivre une par cycle. C'est comme une baguette de pain : elle met 12h à arriver, mais toutes les 30 secondes quelqu'un en achète une.

Aller chercher une valeur dans la RAM, ça prend environ 100 cycles. Le processeur déteste attendre. Alors il a construit un frigo (le cache) à côté de son bureau.

L'unité de contrôle (Control Unit) est le chef d'orchestre. Elle ne calcule rien, elle décide qui fait quoi, quand, et dans quel ordre.

Elle lit le compteur ordinal (%rip), envoie l'adresse de l'instruction au cache L1, ordonne au décodeur de traduire, dit à l'ALU de se réveiller, dit au bus mémoire d'écrire le résultat… bref, c'est le chef de projet qu'on n'a jamais vu coder mais sans qui rien ne sort.

Le bus relie tout ça : le processeur, la RAM, les périphériques. Il y a le bus d'adresse (pour dire où), le bus de données (pour dire quoi), et le bus de contrôle (pour dire comment).

# Quand notre code accède à la mémoire :
movl -12(%rbp), %eax   ; adresse → bus d'adresse
                         ; donnée  → bus de données
                         ; lecture → bus de contrôle

Ça a l'air simple, mais c'est un protocole complexe avec des signaux d'acquittement, de priorité, et des arbitrages parce que oui, les cœurs se battent pour la RAM.

C'est tout bête. On prend une instruction, on la cuisine en cinq étapes, on dépose le résultat, et on recommence des milliards de fois par seconde. C'est ce qu'on appelle le cycle de von Neumann (1945). Ça n'a pas changé depuis. On a juste ajouté de la prédiction, du désordre, du cache, du multi-cœur… mais l'idée de base est toujours là.