Du 6502 à la puce M1 : la boucle qui fait réfléchir chaque processeur

Presque chaque objet du quotidien cache un processeur central, du téléphone au portable en passant par les consoles de jeu et les voitures. L’écart entre générations donne le vertige : la puce 6502 des machines comme l’Apple IIe utilisait seulement 4 528 transistors pour environ 430 000 opérations par seconde, tandis que la puce M1 d’Apple aligne environ 16 milliards de transistors pour près de 3 000 milliards d’opérations par seconde. L’une faisait tourner les premiers jeux et logiciels familiaux, l’autre monte des mondes 3D riches et traite la vidéo avec aisance. Selon wikipedia.org, le 6502 est sorti en septembre 1975 comme microprocesseur 8 bits à 56 instructions.

Le principe commun à tous les processeurs

La thèse centrale affirme que ces deux puces partagent le même ADN technologique , malgré environ 45 ans d’écart. Cet ADN n’est ni le transistor lui-même ni la porte logique, mais une idée d’architecture : chaque processeur va chercher une instruction, comprend ce qu’elle signifie, puis l’exécute. Les processeurs de bureau, les puces de téléphone, les processeurs graphiques et les accélérateurs d’IA héritent tous de ce schéma. Le progrès apparaît alors comme une variation sur un thème durable plutôt qu’une suite de ruptures nettes. Les pièces MOS à bas coût documentées par commodore.ca ont bouleversé le marché avec un prix annoncé de 25 dollars et ont semé toute cette lignée.

Ouvrir un portable moderne rend l’abstraction tangible. La visite passe par le pavé tactile, les cellules de batterie, les haut-parleurs et le ventilateur avant de s’arrêter sur la carte mère, où les puces de stockage SSD conservent les fichiers durablement et les barrettes DRAM servent d’espace de travail provisoire. Sous le caloduc se trouvent la mémoire et le boîtier du processeur lui-même. Ce boîtier empile trois éléments : un couvercle métallique qui diffuse la chaleur, un substrat parcouru de câblage fin et de points de contact, et la pastille de silicium où s’effectue le vrai calcul. Comme annoncé sur apple.com, la puce M1 est arrivée comme une puce gravée en 5 nanomètres avec 16 milliards de transistors et une mémoire unifiée partagée dans tout le processeur.

Le zoom sur la pastille révèle des quartiers aux rôles distincts : coeurs rapides, coeurs sobres en énergie, coeurs graphiques, mémoire cache et tissu de commande qui relie le tout. En descendant encore, la vue devient un labyrinthe de couches de câblage empilées sur des lits de transistors. Un îlot mis en évidence montre six transistors câblés en une seule porte ET, avec environ 650 transistors visibles sur des milliards. Le message passe par l’image : une échelle incompréhensible assemblée à partir d’interrupteurs très ordinaires.

Pour rendre cette échelle saisissable, le récit construit une analogie de bibliothèque où chaque meuble correspond à un matériel. Les rayonnages sont le stockage SSD, vaste mais lent à consulter. Le chariot roulant est la DRAM, un petit lot d’ouvrages amené près du bureau. Le bureau lui-même est le processeur, et le seul livre ouvert posé dessus figure la mémoire cache , rapide mais minuscule. La feuille de papier représente les registres qui tiennent les valeurs en cours d’usage, le crayon lit et écrit l’état, et la calculatrice incarne l’unité arithmétique et logique. Au-dessus de tout cela, une unité de commande infatigable transporte les livres, lit les pages et actionne la calculatrice.

Comment les programmes tournent vraiment

La calculatrice mérite un examen attentif car ses limites définissent ce que le logiciel peut exprimer. Elle travaille en binaire, avec seulement des zéros et des uns, et effectue des opérations simples : additionner, soustraire, avancer ou reculer une valeur d’un cran, et décaler des bits, ce qui en binaire double une valeur comme ajouter un zéro multiplie par dix en décimal. Elle applique aussi des logiques bit à bit comme le ET, le OU et le OU exclusif sur chaque position. Surtout, elle compare deux nombres et lève des drapeaux pour égal, inférieur ou supérieur. Son écran, qui retient chaque résultat, gagne son propre titre : l’ accumulateur .

Tout traitement commence par un chargement : les programmes passent des rayonnages durables vers le chariot DRAM, puis la page active arrive sur le bureau comme un livre ouvert. Chaque livre mêle deux types de pages, des pages d’instructions numérotées étape par étape et des pages de données qui associent adresses et valeurs gardées. La démonstration exécute un chargement qui copie une valeur depuis une adresse de données vers un registre général, une incrémentation qui fait passer la valeur par la calculatrice pour ajouter un, puis une écriture qui renvoie le résultat vers la même adresse. Pour garder le rang dans cette marche, un registre spécial appelé compteur ordinal avance après chaque étape.

Des suites fixes ne suffisent pas à exprimer un vrai logiciel, d’où l’idée suivante : le saut. Une instruction de saut écrit un nombre neuf directement dans le compteur ordinal, ce qui téléporte l’exécution vers l’avant ou vers l’arrière au lieu d’avancer pas à pas. Les branchements sous condition vont plus loin en testant d’abord les drapeaux de comparaison, et c’est ainsi que naissent du matériel les tests SI et les boucles. L’exemple suivi tourne quatre fois : charger un compteur, le comparer à quatre, sortir quand il atteint ou dépasse ce seuil, sinon exécuter le corps puis revenir au début. Le texte lisible à l’écran est du C++, la liste plus proche du matériel est de l’assembleur, et sous les deux dort le code machine binaire.

Ici les chiffres surprennent la plupart des débutants. Le petit 6502 ne comprenait que 56 instructions distinctes, tandis que la puce M1 moderne en gère 354 dans le jeu ArmV8.4, et presque chacune reste volontairement simple. Pourtant chaque jeu, chaque éditeur, chaque navigateur et chaque réponse de modèle n’est au fond qu’une longue suite tirée de ce court menu. Les programmes enchaînent couramment des millions de ces pas, ce qui explique qu’une seule erreur peut faire tomber tout l’édifice. La simplicité en bas et des séquences immenses en haut, voilà tout le secret du calcul général.

Le cycle qui définit chaque processeur

Tout cela se condense dans le cycle chargement-décodage-exécution , le battement de coeur du récit. Pendant le chargement, le contrôleur utilise le compteur ordinal pour repérer l’instruction suivante, la copie dans un emplacement d’attente appelé registre d’instruction en cours, puis fait avancer le compteur. Pendant le décodage, un décodeur d’instructions bâti de portes logiques denses interprète les champs binaires : quelle unité utiliser, quelle opération appliquer, et quels registres l’alimentent. Pendant l’exécution, des signaux électriques minutieusement cadencés acheminent les valeurs des registres vers la calculatrice, laissent les portes se stabiliser, puis verrouillent la réponse dans l’accumulateur ou vers la mémoire. Comme l’explique codecademy.com dans son guide du cycle d’instruction, chargement, décodage et exécution se répètent pour chaque instruction menée à bien.

La vitesse vient du rétrécissement et du chevauchement de cette boucle. Le 6502 battait à environ 1 mégahertz avec des registres larges de 8 bits, si bien que chaque étape durait près d’une microseconde. La puce M1 tourne vers 3,2 gigahertz sur des chemins de 64 bits, ce qui comprime les étapes vers un tiers de nanoseconde tout en brassant des nombres bien plus grands à chaque pas. Les puces modernes ajoutent le pipeline : pendant qu’une instruction s’exécute, la suivante se décode et une troisième se charge, comme une chaîne d’assemblage aux cycles imbriqués. Une unité de prédiction de branchement devine la direction des sauts sous condition pour que le pipeline se bloque rarement, en annulant le travail lors d’un raté occasionnel.

Au-delà du processeur classique

Toutes les puces ne suivent pas ces règles. Les circuits ASIC de minage et les FPGA automobiles sautent le chargement et le décodage et font couler les données dans des portes fixes réglées pour une seule tâche répétitive, avec une efficacité superbe et aucune souplesse. Le matériel quantique s’écarte encore davantage en échangeant les bits contre des qubits et des circuits d’une autre nature. Le récit nomme aussi deux étapes souvent omises, Mémoire et Écriture, qui déplacent les pages entre niveaux de stockage et rangent les résultats, avec des aides comme le registre d’adresse mémoire. Ces transferts restent lents face à l’arithmétique des registres, ce qui explique que certains manuels les plient dans le cycle et que d’autres les traitent à part.

La fin remonte d’un niveau vers la philosophie des jeux d’instructions et le plan des puces. La démo du jeu Snake compile les mêmes 145 lignes de C++ en 676 instructions ARM sur une cible RISC contre environ 560 instructions x86 plus denses en CISC, ce qui oppose des instructions simples et régulières à des instructions moins nombreuses mais plus chargées. Un seul coeur M1 se déplie en caches séparés, un pipeline large de 8, 32 registres généraux, et une arithmétique répartie sur huit petites unités avec des chemins dédiés aux lectures et écritures. Le matériel graphique change d’échelle dans l’autre sens : des milliers de petits coeurs de style CUDA obéissent tous à une seule instruction chargée sur des données différentes. Les arbitrages RISC et CISC débattus sur stackoverflow.com opposent des instructions simples à rythme fixe à des instructions denses de longueur variable avec des décodeurs complexes. Pour le matériel graphique, cornell.edu décrit le modèle SIMT où une instruction se diffuse sur de nombreux fils avec des données distinctes.