Fonctionnement des ordinateurs et exécution des programmes

Un ordinateur reçoit des entrées, suit des instructions pour les traiter, stocke des données et produit des sorties. Ces rôles s’appliquent à un ordinateur portable comme à un contrôleur caché dans un lave-linge. La différence tient à la tâche et aux équipements qui lui sont associés.

Composants physiques et programmes

Le matériel informatique est constitué des équipements physiques. Le logiciel comprend les programmes et les données qu’ils manipulent. Le processeur est la puce de traitement, et non tout le boîtier de l’ordinateur. Une carte mère le relie à la RAM, au stockage, à un processeur graphique, à l’alimentation et aux ports des périphériques. Le processeur graphique s’occupe du dessin et d’autres tâches qui appliquent des opérations similaires à de nombreuses valeurs. Un téléphone réunit de nombreuses fonctions de ce type dans un système sur puce (SoC).

La RAM contient les instructions et les données utilisées à présent. Un support de stockage conserve les programmes et les fichiers enregistrés sans alimentation. Dans un ordinateur décrit comme ayant 16 Go de mémoire et un SSD de 512 Go, la première capacité désigne la RAM et la seconde le stockage. Un support de plus grande capacité ne fournit pas davantage de RAM de travail.

Un programme stocké sous forme de données

L’architecture de von Neumann comprend un processeur, une mémoire principale contenant à la fois les instructions et les données, des périphériques d’entrée-sortie et des bus qui les relient. John von Neumann a décrit cette architecture dans son « First Draft of a Report on the EDVAC » de 1945. Son idée centrale est le programme enregistré : les instructions sont des valeurs binaires en mémoire, prêtes à être lues par le processeur.

Les machines antérieures comme ENIAC étaient configurées pour leurs tâches à l’aide d’interrupteurs et de câbles. Le chargement d’un nouveau programme permet à une machine à programme enregistré de changer de tâche sans modifier son câblage. Le Manchester Baby a exécuté un programme dans une mémoire électronique réinscriptible le 21 juin 1948.

La mémoire n’attache pas de signification à chaque suite de bits. L’octet 01000001 peut représenter le nombre 65, la lettre ASCII « A » ou une partie d’une instruction. Ce que le processeur ou le programme fait de la suite détermine sa signification. Lors de la lecture d’une instruction, le processeur traite la suite de bits lue comme une instruction.

Pourquoi le processeur peut attendre

Les instructions et les données partagent le chemin entre le processeur et la mémoire principale. La mémoire les fournit aussi plus lentement que le processeur ne peut les utiliser. Cette restriction est le goulot d’étranglement de von Neumann. Un processeur rapide peut donc passer du temps à attendre la valeur suivante. De petites mémoires caches rapides conservent des copies utiles près du processeur et réduisent beaucoup de ces attentes.

Les petits microcontrôleurs et processeurs de signal utilisent souvent une architecture Harvard. Les processeurs polyvalents modernes combinent les deux principes : une mémoire principale partagée, mais des mémoires caches de niveau 1 distinctes pour les instructions et les données.

Des ordinateurs dans d’autres appareils

Un système embarqué accomplit une tâche précise à l’intérieur d’un appareil plus grand. Un thermostat lit un capteur de température, traite la mesure et commande le chauffage. Son programme enregistré reste généralement dans une mémoire non volatile. Les rôles du processeur, de la mémoire et des entrées-sorties sont toujours présents, même sans clavier, écran ni système d’exploitation complet pour ordinateur de bureau.

Pour accéder à la mémoire, un processeur a besoin de trois éléments : un emplacement, la valeur à transférer et une commande indiquant à la mémoire ce qu’elle doit faire. Distinguer ces rôles facilite le suivi d’une transaction sur le bus.

Trois rôles sur un bus système classique

Un bus est une voie de communication partagée. Dans un bus système parallèle classique, plusieurs fils ou pistes de carte électronique transportent des bits en même temps.

Une adresse désigne un emplacement ; ce n’est pas la valeur qui y est stockée. L’adresse 200 peut contenir 7 aujourd’hui et 9 plus tard sans changer d’adresse. Une boîte aux lettres numérotée offre une comparaison utile : le numéro désigne la boîte, tandis que son contenu peut changer.

Suivre une lecture et une écriture

Pour lire l’adresse 200, le processeur place 200, soit 11001000 en binaire, sur le bus d’adresses et envoie une commande de lecture sur le bus de contrôle. La mémoire renvoie la valeur à cet emplacement, ici 7, sur le bus de données. Le processeur la copie dans un registre.

Pour écrire 9 à l’adresse 201, le processeur place 201 sur le bus d’adresses, 9 sur le bus de données et une commande d’écriture sur le bus de contrôle. La mémoire remplace le contenu de l’emplacement 201. Envoyer 201 sur le bus de données transmettrait la mauvaise valeur ; l’adresse et le contenu ont des rôles différents.

La largeur d’adresse limite le nombre d’emplacements

Avec $n$ bits d’adresse, il existe $2^n$ adresses différentes. Si chaque adresse désigne un octet, c’est aussi le nombre d’octets adressables.

• 16 bits donnent $2^{16}=65536$ adresses, soit 64 KiB.
• 32 bits donnent $2^{32}=4294967296$ adresses, soit 4 GiB.
• Passer de 20 à 21 bits double la capacité de 1 MiB à 2 MiB.

Chaque bit supplémentaire double le nombre de combinaisons. Doubler le nombre de bits de 16 à 32 multiplie le nombre d’emplacements par $2^{16}$ ; cela ne fait pas que le doubler. Ce calcul donne une limite d’adressage, et non la quantité de RAM réellement installée.

La largeur des données limite chaque transfert

Une voie de données de 64 bits transporte 8 octets en un transfert. Une voie de 8 bits nécessite quatre transferts pour transporter une valeur de 4 octets. La bande passante mesure la quantité de données qui peut être transférée par seconde :

À 1 milliard de transferts par seconde, une voie de 8 octets transporte 8 milliards d’octets par seconde, soit 8 Go/s. La largeur d’adresse détermine le nombre d’emplacements qui peuvent être désignés ; la largeur des données détermine la quantité transférée à la fois.

Un mot est la taille de données qu’un processeur traite naturellement, généralement 32 ou 64 bits. Un processeur 64 bits n’exige pas que chaque connexion possède 64 fils. Sa plage d’adresses effectivement utilisée peut aussi employer moins de 64 bits.

Les liaisons modernes gardent les mêmes rôles

Les canaux mémoire, PCI Express et USB remplacent un bus partagé unique par plusieurs liaisons. PCI Express et USB sont des liaisons série : les bits circulent les uns après les autres sur des paires de fils rapides. Les adresses, les valeurs et les commandes sont regroupées dans des messages. Elles désignent toujours une destination, transportent le contenu et coordonnent le transfert.

Un périphérique d’entrée fournit des données ; un périphérique de sortie présente un résultat ou agit en fonction de celui-ci. Le classement décrit le rôle du périphérique dans le système. Il ne décrit pas la complexité de son fonctionnement interne.

Classer l’action

Les claviers, caméras, microphones, lecteurs de codes-barres et capteurs fournissent des entrées. Les écrans, imprimantes, haut-parleurs et actionneurs fournissent des sorties. Un actionneur modifie un élément physique, par exemple en ouvrant une vanne ou en faisant tourner un moteur.

Certains périphériques font les deux. Un écran tactile détecte les contacts et affiche des images. Un casque-micro combine un microphone et des haut-parleurs. Une carte réseau envoie et reçoit des données. Les supports de stockage effectuent aussi des lectures et des écritures par l’intermédiaire de contrôleurs d’E/S, mais leur rôle principal est de conserver les données : ils forment donc la catégorie distincte de la mémoire secondaire.

Une imprimante peut contenir un processeur qui transforme une page en points imprimables. Elle reste un périphérique de sortie en raison de ce qu’elle fait pour l’ordinateur. Une souris sans fil fournit des entrées comme une souris filaire.

Transformer des signaux continus en nombres

Le son et la température varient de façon continue : ce sont des signaux analogiques. Un convertisseur analogique-numérique (ADC) mesure un signal à intervalles réguliers et encode les échantillons sous forme de nombres. Un convertisseur numérique-analogique (DAC) transforme des valeurs numériques en une sortie analogique, comme le signal qui commande un haut-parleur.

Pour un canal audio échantillonné 44 100 fois par seconde avec 16 bits par échantillon :

C’est le débit des données brutes des échantillons. Chaque seconde contient 44 100 mesures, et chaque mesure nécessite 16 bits. L’échantillonnage et l’encodage permettent à un ordinateur de stocker et de traiter l’enregistrement.

Contrôleur matériel, pilote logiciel

Les périphériques se connectent par des ports ou des liaisons sans fil comme USB, HDMI, Bluetooth ou Wi-Fi. Un contrôleur de périphérique est un circuit qui gère la communication de bas niveau et met à disposition des registres que le processeur peut lire ou modifier. Un pilote de périphérique est un logiciel qui traduit les demandes du système d’exploitation en commandes pour le périphérique. Le contrôleur est du matériel ; le pilote est du logiciel.

Laisser les périphériques demander une intervention

Avec la scrutation, le processeur vérifie régulièrement un registre d’état. C’est simple, mais un périphérique qui est généralement inactif peut entraîner de nombreuses vérifications sans résultat utile.

Avec une interruption, le contrôleur signale qu’une intervention est nécessaire. Dans le modèle simple du cycle d’instruction, le processeur termine l’instruction en cours, sauvegarde l’état interrompu et exécute un gestionnaire d’interruption. Il restaure ensuite l’état sauvegardé et continue. Un appui sur une touche ou la fin d’une lecture sur disque peut déclencher cette séquence.

Les personnes et de nombreux périphériques agissent bien plus lentement qu’un processeur. Une personne ne tape que quelques caractères par seconde, tandis qu’un processeur peut exécuter des milliards d’instructions par seconde. Les interruptions permettent au processeur de travailler entre les événements.

Pour un transfert important, l’accès direct à la mémoire (DMA) permet à un périphérique ou à un contrôleur DMA de déplacer un bloc directement vers la RAM ou depuis celle-ci. Le processeur prépare l’opération et travaille à autre chose. Une interruption de fin lui indique quand le bloc est prêt. L’accès direct à la mémoire évite au processeur de copier chaque octet ; il participe toutefois encore à la préparation et à la conclusion du transfert.

Les opérations les plus élémentaires d’un ordinateur proviennent de circuits qui passent d’un niveau de signal à l’autre entre deux niveaux possibles. Une tension haute représente 1 et une tension basse représente 0. Ces niveaux représentent des bits ; une puce ne reconnaît pas la signification d’une photo ou d’une phrase.

Les portes transforment des bits d’entrée en une sortie

Un transistor fonctionne comme un interrupteur commandé électroniquement. De petits groupes de transistors forment des portes logiques, chacune suivant une règle fixe pour ses entrées et sa sortie. Une table de vérité indique chaque combinaison d’entrées et sa sortie. Avec deux entrées, il existe quatre combinaisons ; en général, $n$ entrées donnent $2^n$ lignes.

La porte NON inverse son unique entrée. Les portes à deux entrées se comportent ainsi :

La porte ET exige que les deux entrées valent 1. La porte OU exige qu’au moins une entrée soit à l’état haut, y compris lorsque les deux le sont. La porte OU exclusif exige des entrées différentes. NON-ET inverse ET ; NON-OU inverse OU. Comprendre OU comme « l’une mais pas les deux » revient à la confondre avec OU exclusif.

Pour évaluer (A AND B) OR (NOT C) avec A = 1, B = 0, C = 0, pars des entrées et progresse vers la sortie. A AND B donne 0. NOT C donne 1. Enfin, 0 OR 1 donne 1. Note les sorties intermédiaires pour que la dernière porte reçoive les bonnes entrées.

Les portes additionnent des chiffres binaires

Un demi-additionneur reçoit deux bits. Sa sortie de somme est un OU exclusif et sa sortie de retenue est un ET. Pour deux entrées valant 1, le bit de somme vaut 0 et le bit de retenue vaut 1 : le résultat sur deux bits est 10, soit 2.

Un additionneur complet reçoit aussi une retenue de la colonne précédente. En chaînant ces circuits, une unité arithmétique et logique peut additionner des nombres plus longs. Suis l’addition de 0110 et 0011 en partant de la droite :

1. La colonne de droite donne 1, sans retenue.
2. La colonne suivante contient deux bits valant 1 : écris 0 et retiens 1.
3. La suivante contient 1, 0 et la retenue 1 : écris 0 et retiens 1.
4. Celle de gauche contient 0, 0 et la retenue 1 : écris 1.

Le résultat est 1001, soit 9. Une retenue appartient à la colonne suivante ; l’oublier change la valeur.

Les portes peuvent conserver un bit

Une rétroaction consiste à renvoyer la sortie d’un circuit vers son entrée. Des portes NON-ET ou NON-OU couplées de façon croisée forment un verrou qui conserve un bit tant que l’alimentation reste active. Une bascule prend en compte un nouveau bit à un front d’horloge, ce qui synchronise les mises à jour avec l’horloge du processeur. Les registres utilisent des circuits de stockage commandés par l’horloge. Les cellules de cache SRAM utilisent des circuits de type verrou ; la DRAM stocke des charges dans des condensateurs.

Les portes NON-ET et NON-OU sont chacune universelles : chaque type de porte permet à lui seul de construire toute fonction logique. Relier les deux entrées d’une porte NON-ET à A donne A NAND A, qui fonctionne comme NON A.

Ce sont des couches d’abstraction. Les transistors construisent les portes ; les portes construisent les additionneurs, les registres et les circuits de commande ; ceux-ci construisent un processeur qui exécute des instructions. Une personne qui programme peut utiliser la couche des instructions sans concevoir les interrupteurs qui se trouvent en dessous.

Le processeur exécute les instructions d’un programme. Son unité de commande dirige le travail, son unité arithmétique et logique effectue les opérations et ses registres contiennent les valeurs nécessaires immédiatement. Une horloge coordonne les changements dans ces circuits.

Diriger et effectuer le travail

L’unité de commande lit une instruction, la décode et émet des signaux de contrôle. Elle peut demander à la mémoire de renvoyer une valeur, sélectionner deux entrées pour l’UAL et autoriser un registre à stocker le résultat. Elle coordonne l’opération ; l’UAL effectue le calcul arithmétique ou logique.

Les opérations de l’UAL comprennent l’addition, la soustraction, les comparaisons, les décalages de bits et les opérations de portes comme ET et OU exclusif. Les résultats mettent aussi à jour des indicateurs d’état. Un indicateur de zéro signale un résultat nul ; un indicateur de signe négatif enregistre un résultat négatif. Un branchement peut tester un indicateur pour choisir l’instruction suivante.

Les registres conservent l’état de travail immédiat

Les registres sont de très petits emplacements de stockage rapides à l’intérieur du processeur. Un registre général contient généralement un mot. Par exemple, x86-64 fournit 16 registres généraux pour les entiers, et ARM 64 bits en fournit 31. Les programmes les utilisent pour conserver des valeurs près de l’UAL.

Le modèle pédagogique du processeur rend visibles les rôles suivants :

Le MDR est aussi appelé registre tampon mémoire (MBR). Le CIR est aussi appelé registre d’instruction (IR). Les puces réelles organisent ces tâches de façon plus complexe, mais le modèle permet de suivre le déplacement d’une instruction et de ses données.

Le PC contient une adresse, et non le nombre total d’instructions terminées. Un saut peut le faire revenir en arrière pour répéter une boucle. Le MAR et le MDR diffèrent aussi : une adresse comme 10 va dans le MAR ; la valeur stockée à l’adresse 10 va dans le MDR.

Un cycle d’horloge est une étape de synchronisation

La fréquence d’horloge compte les impulsions par seconde, mesurées en hertz (Hz). Une horloge à 3 GHz produit 3 milliards de cycles par seconde. La durée d’un cycle est :

Une impulsion permet à des parties d’un circuit d’avancer. Certaines instructions nécessitent plusieurs étapes de synchronisation, et les processeurs modernes font se chevaucher le traitement de plusieurs instructions.

Plusieurs cœurs de traitement

Un cœur dispose des ressources de commande, de calcul, de registres et de mémoire cache nécessaires pour exécuter un flux d’instructions. Quatre cœurs peuvent exécuter quatre flux à la fois. Un programme en profite lorsque son travail peut être réparti entre eux ; posséder quatre cœurs ne répartit pas automatiquement chaque tâche.

Un processeur graphique possède de nombreuses unités de traitement plus petites, adaptées à l’exécution d’opérations similaires sur de nombreuses données. Le dessin de pixels, le traitement vidéo et certains calculs d’apprentissage automatique prennent cette forme. Un processeur central convient à une plus grande diversité d’instructions et de décisions.

Pense à une cuisine : l’unité de commande attribue les actions, l’UAL les effectue, les registres conservent les ingrédients à portée de main et la mémoire en fournit d’autres. Le processeur suit mécaniquement des suites de bits ; c’est le programme qui leur donne un sens utile.

Le cycle de lecture-décodage-exécution fait fonctionner ensemble les composants du processeur pour exécuter un programme. Chaque cycle lit une instruction, détermine son opération et l’effectue. Un suivi d’exécution consigne les changements des registres et de la mémoire afin que chaque résultat ait une cause visible.

Lire l’instruction

Dans le processeur simple, la lecture suit cette séquence :

1. Copier le PC dans le MAR.
2. Placer l’adresse sur le bus d’adresses et envoyer un signal de lecture en mémoire.
3. Recevoir l’instruction dans le MDR par le bus de données.
4. La copier dans le CIR.
5. Faire avancer le PC jusqu’à l’instruction suivante.

Dans la machine pédagogique, chaque instruction occupe un emplacement, donc le PC augmente de 1. Un processeur dont la mémoire est adressable par octet avance de la longueur de l’instruction en octets. Pendant l’exécution, le PC pointe déjà après l’instruction lue.

Décoder, puis exécuter

L’unité de commande sépare le code opération, qui précise l’opération, de l’opérande, qui fournit une valeur, un registre ou une adresse. Elle envoie ensuite les signaux nécessaires à l’exécution de l’instruction. Un chargement lit des données, une addition utilise l’UAL, un stockage écrit des données et un saut modifie le PC. Certaines descriptions font de l’écriture du résultat une étape distincte appelée écriture du résultat.

Suivre l’exécution d’un programme complet

La machine pédagogique possède un accumulateur. Ici, LOAD, ADD et STORE utilisent des adresses mémoire comme opérandes.

Address  Instruction      Data address  Value
0        LOAD 10          10            7
1        ADD 11           11            5
2        STORE 12         12            0
3        HALT

Commence avec le PC à 0. La lecture de LOAD 10 fait passer le PC à 1. L’exécution place l’adresse 10 dans le MAR, lit 7 par le MDR et donne à l’ACC la valeur 7. L’opérande 10 désigne un emplacement ; ce n’est pas la valeur chargée.

Ensuite, ADD 11 est lu et le PC devient 2. L’emplacement mémoire 11 fournit 5. L’UAL additionne 7 et 5, laissant 12 dans l’ACC. La lecture de STORE 12 fait passer le PC à 3. L’exécution place l’adresse 12 dans le MAR et la valeur 12 dans le MDR, puis écrit 12 à cet emplacement. L’ACC reste à 12. Enfin, la lecture de HALT fait passer le PC à 4 et l’exécution arrête la machine pédagogique. Quatre instructions ont été exécutées.

Les branchements remplacent l’adresse suivante

JUMP 0 place 0 dans le PC pendant l’exécution, quelle que soit sa valeur précédente. JUMPZ 6 ne saute que si l’ACC vaut zéro. Si cette instruction a été lue à l’adresse 4, la lecture fait d’abord passer le PC à 5. L’exécution donne ensuite au PC la valeur 6 si l’ACC vaut zéro ; sinon, le PC reste à 5. C’est ainsi qu’une séquence peut choisir un chemin ou répéter une boucle.

Interruptions et processeurs réels

Dans ce modèle, le processeur vérifie les interruptions à la fin d’une instruction. Pour en traiter une, il sauvegarde le PC et les autres registres de travail, exécute le gestionnaire, puis restaure l’état sauvegardé. Le programme interrompu reprend avec ses propres valeurs et sa prochaine adresse.

Un processeur ne lit pas tout un programme source à la fois. Il exécute des instructions machine, souvent plusieurs pour une seule instruction source. Les processeurs modernes font se chevaucher et réordonnent le travail interne tout en préservant les résultats attendus du programme.

Les performances d’un processeur dépendent du travail nécessaire à un programme et de la vitesse à laquelle l’ordinateur l’accomplit. La fréquence d’horloge, le travail utile par cycle, le temps d’attente et les possibilités de travail parallèle comptent tous.

Fréquence d’horloge et nombre fixe de cycles

Pour une tâche nécessitant un nombre connu de cycles d’horloge :

Une tâche nécessitant 6 milliards de cycles prend 2 secondes à 3 GHz et 1,5 seconde à 4 GHz. La comparaison suppose un nombre de cycles fixe. Avec des processeurs de conception différente, un programme peut nécessiter un nombre différent de cycles. Une puce à 3,5 GHz peut donc surpasser une puce à 4 GHz en terminant davantage d’instructions utiles par cycle.

Des fréquences d’horloge plus élevées consomment aussi davantage d’énergie et produisent de la chaleur. Le bridage thermique réduit la fréquence d’horloge lorsqu’un processeur chauffe trop. Cela aide à comprendre pourquoi les gains de performance proviennent d’autres améliorations que la seule augmentation des gigahertz.

Les cœurs ne répartissent que la partie parallélisable

Supposons qu’une tâche prenne 10 secondes sur un cœur. Deux secondes doivent se dérouler en séquence ; huit secondes peuvent être réparties également entre quatre cœurs. En ignorant le surcoût de coordination :

Diviser les 10 secondes entières par quatre donne 2,5 secondes, mais répartit à tort le travail séquentiel. Même un nombre illimité de cœurs ne peut pas supprimer ces deux secondes. Plusieurs cœurs aident aussi des programmes distincts à s’exécuter en même temps, même lorsque chaque programme n’utilise qu’un cœur.

Un pipeline fait se chevaucher les étapes

Dans un pipeline à trois étapes, une instruction s’exécute pendant que la suivante est décodée et qu’une autre est lue. Chaque instruction passe toujours par les trois étapes. Le gain est un plus grand nombre d’instructions terminées pendant une même durée.

Si chaque étape prend un cycle, dix instructions indépendantes prennent 30 cycles sans chevauchement. Un pipeline idéal nécessite trois cycles pour terminer la première instruction et un cycle supplémentaire pour chacune des instructions restantes :

Un branchement peut rendre inutiles des instructions déjà lues. Abandonner ce travail coûte des cycles ; les processeurs prédisent donc les branchements. Les dépendances réelles et les attentes de la mémoire empêchent aussi un pipeline d’atteindre toujours son débit idéal.

Alimenter le processeur en données

Une mémoire cache conserve à proximité des copies d’instructions et de données. Une capacité de cache utile plus grande peut réduire les accès à la RAM, en particulier lorsqu’un programme utilise de façon répétée un ensemble de travail qui ne tenait pas auparavant dans le cache. Si cet ensemble y tient déjà, une capacité supplémentaire peut apporter peu.

La bande passante mémoire limite la vitesse d’arrivée de nombreuses valeurs. La vitesse du stockage compte lors de l’ouverture de fichiers ou du lancement d’applications : passer d’un disque dur à un SSD peut réduire l’attente même si le processeur reste inchangé. La taille des mots et les instructions prises en charge par un processeur influent aussi sur les charges de travail qui lui conviennent.

Davantage de transistors, des usages différents

La loi de Moore décrit l’observation faite par Gordon Moore en 1965 et révisée en 1975, selon laquelle le nombre de transistors doublait environ tous les deux ans. Cette tendance historique n’est pas une règle selon laquelle les programmes deviennent deux fois plus rapides à intervalles fixes. Comme la miniaturisation a ralenti, les concepteurs de puces ont utilisé les transistors supplémentaires pour les cœurs, les mémoires caches, les processeurs graphiques et les accélérateurs spécialisés. Une comparaison utile demande combien de temps prend la même tâche dans les mêmes conditions.

Le code machine est constitué d’instructions binaires destinées à un type particulier de processeur. Le langage d’assemblage écrit ces instructions avec des noms lisibles. Tous deux décrivent des opérations beaucoup plus proches du matériel qu’un langage de haut niveau comme Python ou C.

Opérations et opérandes

Une instruction contient un code opération qui précise ce qu’il faut faire et généralement un ou plusieurs opérandes qui précisent quoi utiliser. Un opérande peut désigner un registre ou une adresse mémoire, ou fournir directement une valeur. Sa signification découle du format défini pour l’instruction.

Prenons un codage pédagogique sur 8 bits. Les quatre premiers bits contiennent un code opération ; les quatre derniers contiennent une adresse. Si LOAD est 0001, alors LOAD 10 devient 0001 1010, car 10 en décimal est 1010 en binaire. Quatre bits de code opération permettent $2^4=16$ codes opération. Quatre bits d’adresse désignent les emplacements de 0 à 15. Ce codage illustre un format limité ; les autres suivis d’exécution de la machine pédagogique utilisent des instructions écrites avec des adresses plus grandes.

Une architecture du jeu d’instructions (ISA) définit les instructions, les codages et les registres qu’un processeur offre. x86-64, ARM et RISC-V en sont des exemples. Les instructions A64 d’ARM ont une longueur de 32 bits ; les instructions x86-64 vont de 1 à 15 octets. La taille des mots d’un processeur 64 bits ne détermine pas la longueur de chaque instruction.

Une boucle lisible

Un assembleur transforme les mnémoniques et les étiquettes du langage d’assemblage en code machine pour une architecture de jeu d’instructions. Parmi les groupes d’instructions utiles figurent le transfert de données, l’arithmétique et la logique, le contrôle du déroulement et les opérations système ou d’E/S.

Ce programme à accumulateur effectue un compte à rebours à partir de 3. SUB 21 soustrait le contenu de l’adresse 21. JUMPZ effectue un branchement si l’ACC vaut zéro.

0  LOAD 20
1  SUB 21
2  STORE 20
3  JUMPZ 5
4  JUMP 0
5  HALT

20 holds 3; 21 holds 1.

Au premier passage, LOAD lit 3, SUB laisse 2 et STORE enregistre 2. Le test de zéro échoue, donc JUMP 0 démarre un autre passage. Le deuxième passage enregistre 1 et revient en arrière. Le troisième enregistre 0, donc JUMPZ 5 va à HALT.

Les deux premiers passages utilisent cinq instructions chacun. Le dernier en utilise quatre avant HALT, qui compte aussi comme une instruction : $5+5+4+1=15$. Ne compter que les six lignes écrites fait oublier les exécutions répétées.

Une instruction source, plusieurs instructions machine

Une instruction de haut niveau comme total = price + tax peut devenir des opérations qui chargent une valeur, en ajoutent une autre et stockent le résultat. Les langages de haut niveau expriment les variables, les choix, les boucles et les fonctions sans nommer chaque registre. En langage d’assemblage, chaque instruction écrite correspond généralement à une instruction machine et dépend étroitement de son architecture de jeu d’instructions.

Du code machine pour x86-64 ne peut pas s’exécuter directement comme du code ARM. Le code source peut être recompilé pour ARM, ou une couche de traduction ou d’émulation peut prendre en charge cette incompatibilité.

RISC et CISC

Les architectures RISC comme ARM et RISC-V privilégient des instructions simples et régulières. Beaucoup utilisent des instructions de longueur fixe, mais RISC-V peut mélanger des formes compressées de 16 bits et des instructions standard de 32 bits. Les architectures CISC comme x86 proposent des instructions plus complexes et de longueur variable. Les processeurs x86 modernes décomposent les instructions en opérations internes plus simples. Ces désignations décrivent des approches de conception et ne garantissent pas qu’une machine est plus rapide.

Le code source est le texte lisible d’un programme. Un processeur exécute des instructions machine : un outil doit donc faire le lien. La compilation et l’interprétation décrivent des façons de le faire ; de nombreuses implémentations réelles les combinent.

Les outils de traduction

La plupart des compilateurs travaillent avant le démarrage d’un programme. Un compilateur à la volée travaille pendant l’exécution. Un interpréteur est lui-même un programme en code machine : le processeur exécute l’interpréteur, qui effectue les opérations du programme source.

Suivre la construction d’un programme C

La commande clang hello.c -o hello construit un exécutable nommé hello à partir de hello.c. Un outil de construction comme make peut organiser les commandes du compilateur pour la personne qui programme. Les principales étapes sont :

1. Prétraitement : traiter les directives comme #include <stdio.h>, en intégrant les déclarations des fichiers d’en-tête au code source.
2. Compilation : traduire le code C en opérations de niveau assemblage.
3. Assemblage : encoder ces opérations en code machine dans des fichiers objets.
4. Édition de liens : relier le code objet et les références aux bibliothèques pour produire un exécutable.

Les fichiers d’en-tête décrivent les interfaces des bibliothèques ; inclure un fichier d’en-tête ne copie pas en soi l’implémentation compilée de la bibliothèque dans le programme. L’édition de liens fournit la connexion à ce code. L’édition de liens statique copie le code de bibliothèque nécessaire dans l’exécutable. L’édition de liens dynamique enregistre les dépendances aux bibliothèques partagées, qui sont chargées et reliées lorsque nécessaire.

L’exécutable cible une architecture de jeu d’instructions et un format de système d’exploitation. La construction pour un Mac ARM et pour un ordinateur Windows x86-64 nécessite donc des constructions natives distinctes. La modification du code source exige aussi de reconstruire un exécutable compilé avant que la modification prenne effet.

Les erreurs surviennent à différentes étapes

Un compilateur peut signaler des erreurs de syntaxe, comme un point-virgule manquant en C, et des erreurs de type lorsque le langage vérifie les types. Une compilation réussie ne prouve pas que le programme résout le bon problème. Une erreur de logique produit un mauvais résultat. Une erreur d’exécution se produit pendant l’exécution du programme, par exemple une division par une valeur d’entrée qui s’avère être zéro.

Un interpréteur simple peut n’atteindre une erreur qu’après l’exécution des instructions précédentes. Python vérifie d’abord la syntaxe d’un fichier entier, mais un nom non défini peut tout de même provoquer une erreur uniquement lorsque l’exécution l’atteint. La seule méthode de traduction ne permet pas de savoir quand chaque type d’erreur est détecté.

Bytecode et machines virtuelles

Java compile le code source en bytecode, des instructions pour la machine virtuelle Java (JVM). Chaque plateforme prise en charge fournit sa propre JVM. Celle-ci peut interpréter le bytecode et compiler à la volée les parties fréquemment utilisées en code machine pour le processeur local. Le bytecode reste portable parce que la JVM propre à chaque plateforme gère les différences matérielles.

CPython compile aussi Python en bytecode et l’exécute avec une machine virtuelle. PyPy utilise un compilateur à la volée, et les moteurs JavaScript des navigateurs utilisent également la compilation à la volée. « Compilé » et « interprété » décrivent des implémentations, et non des propriétés permanentes d’un langage.

Le code natif compilé à l’avance évite généralement de répéter le travail d’interprétation. L’interprétation facilite le cycle de modification et d’exécution, tandis que le bytecode et la compilation à la volée combinent portabilité et optimisation pendant l’exécution. Dans tous les cas, le processeur suit finalement des instructions machine et le système d’exploitation charge le code exécutable nécessaire en mémoire.

La mémoire principale contient les instructions et les données actuellement disponibles pour le processeur. Pour une application ordinaire stockée sur un SSD, le système d’exploitation commence par charger le code et les données nécessaires dans la RAM. Le processeur lit ensuite les instructions par son système de mémoire et de caches.

RAM, DRAM et SRAM

La mémoire vive (RAM) est une mémoire à accès direct : un emplacement peut être atteint sans passer par tous les emplacements précédents. La RAM de travail ordinaire est volatile ; son contenu est donc perdu sans alimentation. Enregistrer un document copie ses données sur un support de stockage non volatile.

La mémoire principale utilise la DRAM, qui stocke les bits sous forme de charges dans de petits condensateurs. La charge se dissipe, si bien que les cellules ont besoin d’un rafraîchissement, généralement sur un intervalle de 64 ms. La SRAM utilise des circuits de transistors de type verrou qui conservent leur état tant qu’ils sont alimentés. Elle n’a pas besoin de rafraîchissement, mais prend davantage de place et coûte plus cher par bit. Sa vitesse convient aux mémoires caches du processeur.

La mémoire morte (ROM) est une mémoire non volatile associée à des instructions fixes comme le micrologiciel. Les micrologiciels UEFI ou BIOS modernes se trouvent normalement dans une mémoire flash modifiable. La capacité de stockage de fichiers annoncée pour un téléphone est du stockage flash, même lorsqu’une description l’appelle de manière informelle « ROM » ; le téléphone y écrit régulièrement des fichiers.

Un octet possède une adresse

Dans une mémoire adressable par octet, chaque adresse désigne un octet. Un entier de 4 octets commençant à l’adresse décimale 1 000 occupe les emplacements 1 000, 1 001, 1 002 et 1 003. Le prochain emplacement inutilisé est 1 004. Les adresses sont souvent écrites en hexadécimal, comme 0x7FFE0010, car l’hexadécimal représente les suites de bits de manière compacte.

L’adresse indique où se trouvent les octets. Lire le nombre écrit comme adresse est différent de lire la valeur stockée à cette adresse.

Les unités de capacité utilisent deux systèmes

Un octet contient 8 bits. La lettre b minuscule désigne les bits ; la lettre B majuscule désigne les octets.

Un support vendu pour 1 TB contient ${10}^{12}$ octets. En GiB, le nombre est :

Certains systèmes d’exploitation affichent ce nombre binaire avec la notation « GB ». La différence provient de la taille de l’unité ; elle n’indique pas qu’il manque de l’espace.

La capacité diffère de la vitesse du processeur

Davantage de RAM permet de garder prêts à l’emploi simultanément davantage de programmes en cours et de données. Lorsque les données de travail dépassent la capacité de la RAM, le système d’exploitation peut déplacer des pages vers le stockage, ce qui ralentit l’accès. Ajouter de la RAM remédie à ce manque, mais n’augmente pas la fréquence d’horloge du processeur. Supprimer des fichiers enregistrés libère de l’espace de stockage. Fermer des programmes ou des onglets inutiles peut libérer de la RAM de travail.

La mémoire secondaire conserve les programmes et les fichiers sans alimentation. Par rapport à la RAM, elle offre davantage de capacité à un coût par octet inférieur, mais son accès est plus lent. Les différentes technologies de stockage font des compromis entre vitesse, coût, portabilité et durabilité.

Disques magnétiques et SSD

Un disque dur stocke des motifs magnétiques sur des plateaux en rotation. Une tête mobile cherche la bonne piste, puis attend que la partie voulue du plateau passe sous elle. Ces deux mouvements ajoutent un délai d’accès.

À 7 200 tours par minute, un tour prend :

L’attente moyenne due à la rotation est d’un demi-tour, soit environ 4,2 ms. Ce n’est que la partie due à la rotation, et non le temps de lecture complet ; la recherche et le transfert prennent aussi du temps. Les pièces mobiles rendent également un disque dur en fonctionnement vulnérable aux chocs.

Un SSD stocke des charges dans des cellules flash et ne possède aucune pièce mobile. Les petites lectures à des emplacements aléatoires prennent des dizaines de microsecondes au lieu des millisecondes habituelles pour l’accès à un disque dur. Les SSD sont silencieux, résistent aux chocs et conviennent aux ordinateurs portables. Les disques durs offrent généralement un coût par téraoctet inférieur pour les grandes collections.

Les cellules flash supportent un nombre limité de cycles d’effacement et d’écriture. Le contrôleur utilise la répartition de l’usure pour répartir les écritures entre les cellules. Les clés USB, les cartes mémoire et le stockage des téléphones utilisent aussi la mémoire flash, même si le contrôleur et l’interface influent sur leurs performances.

Disques optiques et bandes

Les capacités courantes sont d’environ 700 Mo pour un CD, 4,7 Go pour un DVD simple couche et 25 Go pour un disque Blu-ray simple couche. Les supports optiques sont faciles à transporter, mais lents par rapport aux supports modernes.

La bande offre un faible coût pour les grandes archives. Son accès séquentiel signifie que le lecteur doit la faire défiler pour atteindre un fichier éloigné. Les disques et les SSD offrent un accès direct, qui permet d’atteindre un emplacement choisi sans parcourir toutes les données précédentes. La bande convient donc mieux aux sauvegardes groupées planifiées qu’à une application qui ouvre régulièrement de petits fichiers dispersés.

Le stockage dans le cloud est un service

Le stockage dans le cloud conserve les fichiers sur des équipements situés dans les centres de données d’un fournisseur. Les supports sous-jacents restent des SSD, des disques durs ou des bandes. Une connexion réseau ajoute des délais d’accès et de transfert. Le service offre le partage, l’accès à distance et des copies hors site, avec des frais réguliers et une dépendance aux contrôles d’accès et à la fiabilité du fournisseur.

Tenir compte du facteur limitant

Le temps d’accès est le délai avant que les données commencent à arriver. Le débit de transfert mesure leur vitesse de circulation ensuite. De nombreuses lectures de petits fichiers subissent à chaque fois le délai d’accès ; pour un seul grand fichier continu, le débit de transfert compte davantage.

Un SSD convient aux programmes utilisés sur un ordinateur portable. Les disques durs conviennent à un serveur qui stocke économiquement 20 To de vidéo. Une bande ou une archive dans le cloud convient aux documents d’une entreprise conservés à long terme, tandis qu’une clé USB est pratique pour transporter des fichiers. Choisis selon la capacité, le temps d’accès, le débit de transfert, le coût par octet, la consommation d’énergie, la fiabilité et la portabilité. Être composé de puces ne fait pas d’un SSD une RAM de travail : il reste un stockage non volatile accessible par un contrôleur de stockage.

Un ordinateur combine plusieurs types de stockage parce qu’aucune technologie ne réunit à elle seule un accès rapide, une grande capacité et un faible coût. La hiérarchie mémoire place une petite quantité de stockage très rapide près du processeur et des stockages plus grands et plus lents plus loin.

Les niveaux de la hiérarchie

Du plus rapide et du plus petit vers le plus lent et le plus grand, les principaux niveaux sont les registres, les caches L1/L2/L3, la RAM, le SSD, le disque dur et le stockage d’archives. Le coût par octet baisse généralement à mesure que la capacité augmente.

Ces temps donnent un ordre de grandeur et non une caractéristique fixe pour chaque appareil. En prenant 1 ns pour L1, 100 ns pour la RAM et 10 ms pour un disque, la RAM prend environ 100 fois plus de temps que L1 et le disque environ 100 000 fois plus de temps que la RAM.

Succès, défauts et copies utiles

Une mémoire cache du processeur utilise de la SRAM pour conserver des blocs copiés depuis la mémoire principale. Le matériel parcourt les niveaux de cache avant de lire la RAM. Un succès de cache signifie que le contenu demandé est trouvé dans le cache. Un défaut de cache nécessite une lecture à un niveau plus lent et peut amener une copie dans le cache.

Le taux de succès est le nombre de succès divisé par le nombre total d’accès. Pour 950 succès en 1 000 accès, il est de 95 %. Un défaut ne signifie pas que les données sont manquantes ou endommagées ; il signifie que la copie rapide n’était pas disponible.

Pourquoi les accès passés permettent de prévoir les accès futurs

La localité temporelle signifie qu’un contenu récemment utilisé a de bonnes chances d’être bientôt réutilisé. Une boucle lit de façon répétée un compteur et ses propres instructions. La localité spatiale signifie que des adresses voisines ont de bonnes chances d’être bientôt utilisées. La lecture d’éléments consécutifs d’une liste suit ce schéma.

Une mémoire cache charge une ligne de cache entière, généralement 64 octets voisins, en tirant parti de la localité spatiale. Plusieurs niveaux établissent un compromis entre capacité et temps de recherche : un seul cache énorme prendrait plus de temps à parcourir.

Calculer le délai moyen

Supposons qu’une vérification du cache prenne 1 ns et qu’un accès à la RAM prenne 100 ns. Un défaut coûte les deux, donc prend 101 ns. Avec un taux de succès de 95 % :

Avec un taux de succès de 80 % :

La deuxième moyenne est $21÷6=\mathrm{3,5}$ fois plus grande. Pondère le coût complet des succès et celui des défauts par leur fréquence respective. Oublier la vérification du cache lors d’un défaut changerait la réponse dans ce modèle.

La mise en cache au-delà du processeur

Le système d’exploitation met en cache le contenu des fichiers dans la RAM. Un navigateur met en cache les fichiers web téléchargés sur le support de stockage, et les réseaux de diffusion de contenu conservent des copies près des utilisateurs. Tous réutilisent des copies proches pour éviter des récupérations lentes répétées. Vider le cache d’un navigateur supprime les fichiers du navigateur ; cela ne vide pas les circuits de cache du processeur. Les caches du processeur contiennent de petits blocs de mémoire, et non une bibliothèque organisée de documents entiers.

Un système d’exploitation gère le matériel et fournit des services aux applications. Windows, macOS et Linux équipent les ordinateurs personnels et les serveurs ; Android et iOS équipent les appareils mobiles. Le bureau visible ne représente qu’une partie de ce travail.

Gérer les ressources et masquer les détails du matériel

En tant que gestionnaire de ressources, le système d’exploitation attribue le temps du processeur, la mémoire de travail, les fichiers et les périphériques aux programmes et aux utilisateurs. En tant qu’abstraction, il fournit des opérations plus simples qui masquent les détails du matériel. Un éditeur de texte peut demander « ouvre le fichier report.txt » sans choisir les pistes du disque ni les commandes du périphérique.

L’interface utilisateur permet de demander ces opérations. Une interface graphique utilise des fenêtres, des icônes, des menus et le toucher ou un pointeur. Une interface en ligne de commande accepte des commandes saisies. Des commandes comme ls sous Linux et macOS ou dir sous Windows affichent la liste des fichiers ; des scripts peuvent combiner des commandes pour des tâches répétées.

Le noyau contrôle les opérations privilégiées

Le noyau est le cœur du système d’exploitation responsable du contrôle du matériel et des ressources protégées. Les applications s’exécutent en mode utilisateur avec des privilèges restreints. Le code du noyau s’exécute en mode noyau avec des privilèges plus étendus. Une application demande un service protégé au moyen d’un appel système, par exemple pour demander au système d’exploitation de lire un fichier.

Le noyau vérifie les autorisations et effectue l’action permise. Une application défectueuse ne peut pas simplement utiliser une instruction normale du mode utilisateur pour prendre le contrôle de tous les périphériques ou lire la mémoire protégée d’un autre processus.

Partager le temps du processeur

L’ordonnanceur décide quel programme prêt à s’exécuter reçoit du temps processeur. De courts tours sur un seul flux de traitement donnent l’impression que la lecture de musique et la modification d’un document sont simultanées. Plusieurs cœurs permettent aussi d’exécuter du travail au même moment. Certains processeurs prennent en charge le multithreading matériel au sein d’un cœur, mais le partage du temps reste nécessaire lorsque le travail prêt à être exécuté dépasse ce que le matériel peut effectuer simultanément.

Donner des noms aux fichiers et des pilotes aux périphériques

Un système de fichiers suit le contenu des fichiers et leurs métadonnées comme la taille, les dates et les autorisations. Les dossiers forment une hiérarchie ; un chemin désigne un fichier, par exemple /home/sam/notes.txt sous Linux. NTFS, APFS et ext4 sont des exemples de systèmes de fichiers.

Supprimer un fichier retire généralement son entrée du répertoire et libère son espace pour qu’il soit réutilisé. Cela diffère de l’écrasement volontaire de chaque octet. Les anciennes données peuvent parfois rester récupérables, en particulier sur les disques durs ; une suppression ordinaire ne garantit pas un effacement sécurisé.

Un pilote traduit les demandes générales relatives à un périphérique en commandes qu’un contrôleur comprend. Les pilotes standard prennent en charge de nombreux claviers et clés USB, tandis que certains périphériques nécessitent un pilote spécifique.

Associer chaque logiciel à son rôle

Le système d’exploitation, les pilotes et les utilitaires comme les outils de sauvegarde sont des logiciels système. Les navigateurs, les éditeurs, les jeux et les tableurs sont des applications. Les systèmes mobiles mettent l’accent sur l’autonomie de la batterie, le tactile et la séparation des applications ; les serveurs prennent en charge les services réseau. Un système d’exploitation temps réel respecte des délais de réponse fixés pour des tâches de commande. Des appareils embarqués très simples peuvent exécuter un programme sans système d’exploitation complet.

Le démarrage d’un ordinateur et le lancement d’une application comportent des étapes différentes. Le démarrage donne le contrôle au système d’exploitation. Le chargement d’une application crée ensuite un processus en cours d’exécution qui utilise le processeur, la mémoire et les services du système d’exploitation.

Commencer par des instructions persistantes

À la mise sous tension, la RAM de travail ne contient aucun programme en cours d’exécution utilisable. Le processeur commence par le micrologiciel stocké dans une mémoire non volatile. Sur un PC moderne, le micrologiciel UEFI prépare le matériel et effectue des vérifications de démarrage, souvent appelées autotest au démarrage (POST). Il choisit un périphérique de démarrage et lance un chargeur d’amorçage. Celui-ci charge le noyau du système d’exploitation dans la RAM et lui transmet le contrôle. Le noyau prépare la gestion de la mémoire, les pilotes et les services avant l’apparition de l’écran de connexion ou d’accueil.

Transformer un fichier programme en processus

Un programme est constitué d’instructions stockées. Un processus est une instance en cours d’exécution, avec sa mémoire, l’état de ses registres et ses ressources. Des instances distinctes d’un même éditeur peuvent conserver des documents distincts, même si elles proviennent du même fichier programme.

Pour lancer une application, le système d’exploitation vérifie l’exécutable et l’autorisation de l’exécuter, crée un espace d’adressage, charge le code et les données nécessaires au départ, prépare une pile et définit l’adresse de l’instruction de départ. D’autres pages peuvent être chargées au moment de leur utilisation. L’ordonnanceur accorde du temps processeur au processus, dont les instructions machine sont alors exécutées.

Des zones différentes pour des contenus différents

L’appel d’une fonction ajoute des informations à la pile ; le retour libère la partie de cet appel. Des appels répétés sans arrêt peuvent épuiser la pile et provoquer un débordement de pile. Une fuite mémoire se produit lorsqu’un programme conserve de la mémoire dont il n’a plus besoin, ce qui augmente la mémoire qu’il garde allouée. Le simple fait d’utiliser une grande quantité de mémoire ne suffit pas à diagnostiquer une fuite.

Distinguer les adresses des emplacements physiques

La mémoire virtuelle donne à chaque processus son propre espace d’adressage. Le système d’exploitation et l’unité de gestion mémoire (MMU) du processeur font correspondre les adresses virtuelles à la RAM physique par pages, souvent de 4 KiB. Deux processus peuvent utiliser 0x1000 pour des emplacements physiques différents. Les autorisations d’accès empêchent les lectures ou écritures non autorisées ; le système d’exploitation peut aussi autoriser explicitement des pages partagées.

Un accès interdit provoque une erreur qui peut mettre fin au processus. Sous Linux ou macOS, un programme C peut signaler une « erreur de segmentation ». Une adresse virtuelle désigne un emplacement dans l’espace d’adressage du processus, et pas nécessairement un octet de RAM portant le même numéro.

Lorsque la demande de mémoire est élevée, le système d’exploitation peut déplacer les pages inactives vers un fichier d’échange ou de pagination sur le stockage. Dans cet exemple, récupérer une page en 100 µs prend environ 1 000 fois le temps d’un accès à la RAM de 100 ns. Le déplacement répété de pages, appelé écroulement du système, peut occuper l’essentiel du temps d’exécution. Réduire la demande de mémoire active ou ajouter de la RAM peut aider.

Suivre un appui sur une touche à travers les couches

Un contrôleur de clavier signale une interruption. Le gestionnaire et le pilote du système d’exploitation obtiennent l’événement et le transmettent au processus de l’éditeur. L’éditeur met à jour le document dans sa mémoire et demande aux services graphiques du système d’exploitation d’actualiser l’affichage. L’enregistrement demande au système de fichiers d’écrire le document sur le stockage. Lorsque le processus se termine, le système d’exploitation récupère sa mémoire et ses ressources. Les données enregistrées restent ; les modifications conservées uniquement dans la mémoire du processus disparaissent.