Microprocesseurs : l'évolution de l'informatique à programme stocké

Aux premiers jours de l'informatique, des pionniers tels qu'Alan Turing et John von Neumann ont reconnu qu'une machine véritablement utile doit faire plus que simplement exécuter une liste de commandes — elle doit être capable de stocker, récupérer et modifier des données dans la même réserve de mémoire. Cette idée a mené au concept d'ordinateur à programme stocké.

La machine théorique de Turing reposait sur une bande à accès séquentiel pour contenir à la fois les instructions de programme et les données. Un circuit de contrôle lisait la bande, effectuait des opérations, et réécrivait les résultats sur la bande ou déplaçait la bande pour lire de nouvelles données. Les systèmes modernes remplacent cette bande par de la mémoire à accès aléatoire (RAM), atteignant le même but avec une vitesse et flexibilité bien supérieures.

Une analogie utile vient du contrôle précoce de machines-outils automatique. Les systèmes de commande numérique (CN) à boucle ouverte guidaient un tour ou une fraiseuse en suivant des instructions encodées comme trous dans une bande de papier. La machine se déplaçait aveuglément, suivant la bande sans conscience de l'état de la pièce.

Parce que le dispositif était « aveugle » à son environnement, il ne pouvait pas compenser des changements tels que la dilatation du métal ou l'usure de l'outil. Le programmeur devait aussi anticiper chaque séquence d'instructions possible, puisque la bande était en lecture seule et la machine n'avait pas de mémoire interne pour suivre son état.

La mise à niveau vers une machine à états finis (MEF) a donné à l'outil une mémoire rudimentaire : en réinjectant certains bits de données dans la logique d'adresse, le système pouvait se souvenir d'états simples comme « liquide de refroidissement activé » ou « outil en position ». Pourtant, cela restait loin de la vraie flexibilité.

La percée vint avec la commande numérique à boucle fermée (CNC), où le programme pouvait écrire de nouvelles données dans une mémoire inscriptible (RAM). Le système de contrôle pouvait alors enregistrer ce qu'il avait fait et s'adapter aux changements détectés par capteurs — un peu comme un machiniste notant des notes sur un bloc-notes pour référence ultérieure.

Les informaticiens ont longtemps rêvé de machines pouvant modifier leur propre code, miroir du cerveau humain renforçant les synapses par l'expérience. Pour que de tels programmes auto-modifiants soient faisables, le code exécutable doit résider dans la même mémoire inscriptible qui stocke les données — une notion qui reste à la frontière de la recherche aujourd'hui.

La plupart des logiciels suivent encore des séquences d'instructions fixes, n'altérant qu'un champ de données séparé. Pour vraiment supporter le modèle à programme stocké, nous avons besoin de plus qu'une MEF ; nous avons besoin d'une mémoire lecture/écriture, d'une unité de traitement de données, et d'un contrôleur sophistiqué.

La mémoire lecture/écriture est aisément fournie par des puces RAM statique ou dynamique — abordables et rapides. Les opérations logiques sont gérées par une Unité Arithmétique et Logique (UAL), qui peut effectuer des fonctions arithmétiques et booléennes.

L'Unité de Contrôle orchestre le mouvement des données entre mémoire, UAL et dispositifs externes. Elle utilise des tampons tri-state pour router les données sur les bus et une logique de décodage pour traduire les codes d'instruction binaires en actions.

Des instructions exemples pourraient être : « Ajoutez la valeur à l'adresse 0010 à la valeur à l'adresse 1101 », ou « Calculez la parité de l'octet à l'adresse 0111 ». Le mappage des codes binaires aux opérations est arbitraire, un peu comme le standard ASCII initial, bien que les jeux d'instructions soient généralement spécifiques au fabricant.

Quand la mémoire lecture/écriture, une UAL et une Unité de Contrôle sont intégrées — souvent sur une seule puce — elles forment un processeur. Un processeur avec mémoire externe minimale est un microprocesseur ; couplé avec une circuitry de contrôle de bus, il devient une Unité Centrale de Traitement (UCT).

L'opération de l'UCT est encapsulée dans le cycle recherche/exécution. Le compteur de programme tient l'adresse de la prochaine instruction. L'Unité de Contrôle lit cette adresse sur le bus d'adresse mémoire, récupère l'instruction depuis la RAM, et la stocke dans un registre temporaire.

Si l'instruction nécessite des opérandes, l'Unité de Contrôle émet des accès mémoire additionnels, routant les données récupérées vers les registres de l'UAL. L'UAL effectue alors l'opération demandée, plaçant le résultat dans l'accumulateur. Finalement, le compteur de programme s'incrémente, et le cycle se répète.

 

Microprocesseur (UCT)

--------------------------------------
| ** Compteur de programme ** |
| (incrémente valeur d'adresse envoyée |
| à puce(s) mémoire externe pour |
| récupérer la prochaine instruction) |==========> Bus d'adresse
| (vers mémoire RAM) |
--------------------------------------
| ** Unité de Contrôle ** |<=========> Bus de contrôle
| (décode instructions lues depuis | (vers tous dispositifs partageant
| programme en mémoire, active flux | bus d'adresse et/ou de données;
| de données vers et depuis UAL, | arbitre toutes communications
| registres internes, et dispositifs | sur bus)
| externes) |
--------------------------------------
| ** Unité Arithmétique et Logique (UAL) ** |
| (effectue tous calculs mathématiques |
| et fonctions booléennes) |
--------------------------------------
| ** Registres ** |
| (petites mémoires lecture/écriture pour |<=========> Bus de données
| tenir codes d'instruction, | (depuis mémoire RAM et autres
| codes d'erreur, données UAL, etc; | dispositifs externes)
| inclut l' « accumulateur ») |
--------------------------------------

 

Même les opérations les plus simples nécessitent de nombreux micro-étapes. L'arithmétique complexe comme l'exponentiation implique des itérations répétées de fonctions de base. Considérez les milliers de cycles qu'un moteur graphique de simulateur de vol doit effectuer pour rafraîchir l'affichage chaque image.

La vitesse pure du cycle recherche/exécution rend cela faisable. Certains designs intègrent un petit programme — appelé microcode — dans une ROM interne. Le microcode gère les sous-étapes des opérations complexes, permettant au programmeur d'émettre une seule instruction de haut niveau au lieu d'écrire chaque détail.

De cette façon, un processeur contient un processeur : un programme s'exécutant à l'intérieur d'un programme qui simplifie le développement tout en préservant la performance.