Abstractions et performance des ordinateurs

Une abstraction montre ce que fait un composant tout en masquant les détails de son fonctionnement. Un navigateur peut demander au système d’exploitation de lire un fichier sans contrôler les circuits du périphérique de stockage. Des interfaces définies permettent de concevoir, de tester et de remplacer des parties d’un système sans reconstruire toutes les couches à la fois.

Les couches et leurs rôles

Voici un ordre courant, de la tâche de l’utilisateur aux dispositifs physiques :

1. Les logiciels applicatifs effectuent des tâches comme modifier une feuille de calcul ou naviguer sur le web.
2. Les logiciels système fournissent des services partagés et traduisent les programmes. Ils comprennent les systèmes d’exploitation, les compilateurs, les assembleurs, les éditeurs de liens et les bibliothèques.
3. L’architecture du jeu d’instructions (ISA) définit les instructions machine et les autres comportements visibles par les logiciels de bas niveau.
4. La microarchitecture, ou organisation, implémente cette ISA à l’aide d’un chemin de données, d’une unité de commande, de pipelines et de caches.
5. La logique numérique construit les opérations et le stockage à partir de portes, d’additionneurs, de multiplexeurs et de registres.
6. Les circuits relient les composants électroniques pour réaliser cette logique.
7. Les dispositifs, principalement les transistors, assurent la commutation physique.

Ces frontières offrent des vues utiles d’une même machine. Différents diagrammes peuvent regrouper des couches voisines. Un système d’exploitation est un logiciel : le processeur exécute ses instructions, y compris des instructions privilégiées qui l’aident à gérer les ressources en toute sécurité.

Suivre une addition

Considère l’instruction C total = price + tax;. Un compilateur choisit où sont placées les valeurs et quelles instructions effectuent l’addition. Il peut choisir une instruction d’addition sans concevoir d’additionneur. Un concepteur de microarchitecture associe cette instruction au matériel d’exécution. Un concepteur logique construit l’additionneur à partir de portes ; un concepteur de circuits s’occupe des détails électriques de ces portes. Chaque personne utilise une interface plus simple vers le niveau inférieur.

L’ordinateur physique possède cinq composants classiques : entrée, sortie, mémoire, chemin de données et unité de commande. Le chemin de données effectue des opérations sur les données. L’unité de commande dirige les opérations et coordonne la mémoire et les entrées-sorties. Ensemble, le chemin de données et l’unité de commande forment le processeur, ou CPU.

Un transistor agit comme un interrupteur commandé électriquement. Un circuit intégré, ou puce, réunit de nombreux transistors sur une même plaquette de silicium. Ces interrupteurs permettent de réaliser la logique ; la logique permet de réaliser les instructions ; les instructions permettent d’exécuter les logiciels.

Davantage de transistors et des vitesses différentes

La loi de Moore découle de l’observation de Gordon Moore en 1965, révisée en 1975 : le nombre de transistors tendait à doubler environ tous les deux ans. Dix doublements de ce type multiplient un nombre par $2^{10}=1024$, en environ 20 ans. C’est une tendance de fabrication, pas une garantie physique ; son rythme a ralenti.

Le respect d’une interface préserve le comportement qu’elle promet. Il ne détermine pas la performance, la consommation d’énergie ou le coût. Deux processeurs peuvent implémenter correctement la même instruction d’addition tout en utilisant des circuits, des caches et des fréquences d’horloge différents. L’application obtient le même résultat, mais attend pendant une durée différente.

Un processeur exécute le langage machine, constitué d’instructions codées en bits. Le code de haut niveau décrit un calcul à l’aide de variables, d’expressions, de boucles et de fonctions. La traduction relie ces deux représentations, en développant souvent une courte instruction de haut niveau en plusieurs instructions machine.

Le parcours d’un programme compilé

Pour un programme C, les étapes principales sont les suivantes :

Un fichier objet peut contenir du code machine sans être encore un programme complet exécutable. Par exemple, l’appel d’une fonction définie dans un autre fichier nécessite que l’éditeur de liens résolve cette référence. Le chargeur fait partie des mécanismes d’exécution du système d’exploitation ; ce n’est pas un autre traducteur de code source.

Suivre une instruction C

Supposons que price se trouve dans le registre x6, que tax soit dans x7 et que le compilateur place total dans x5. Alors :

total = price + tax;

peut devenir cette instruction RISC-V :

add x5, x6, x7

La destination vient en premier dans le texte d’assemblage. L’instruction additionne les valeurs de x6 et x7 et écrit le résultat dans x5. Son codage de type R sur 32 bits place les champs dans un ordre différent :

La réunion des champs donne 0000000 00111 00110 000 00101 0110011, soit 0x007302B3. Les espaces rendent les champs lisibles ; ils ne sont pas stockés dans l’instruction.

Une instruction source ne correspond pas nécessairement à une seule instruction machine. Même si tous les opérandes sont dans des registres, f = (g + h) - (i + j); nécessite deux additions et une soustraction. Le chargement des opérandes depuis la mémoire ajoute des instructions. Le nombre d’instructions exécutées dépend donc de la traduction et de l’ISA, pas seulement du nombre de lignes source.

D’autres chemins vers le code machine

Un programme de haut niveau peut souvent être recompilé pour une autre ISA. Son exécutable existant est lié à son ISA et aux conventions du système d’exploitation. Un exécutable x86-64 doit être recompilé, émulé ou traduit sous forme binaire pour fonctionner sur une machine Arm ou RISC-V qui ne peut pas l’exécuter nativement.

Le bytecode est un format intermédiaire d’instructions pour un environnement d’exécution. CPython compile le code source Python en bytecode et l’interprète à l’aide d’un programme interpréteur. Les machines virtuelles Java utilisent couramment la compilation à la volée pour transformer le bytecode fréquemment utilisé en code machine pendant l’exécution du programme. Dans les deux cas, le processeur physique exécute finalement des instructions machine.

L’assemblage reste du texte, même lorsqu’une ligne ressemble étroitement à une instruction réelle. Une pseudo-instruction est une facilité acceptée par l’assembleur : en RISC-V, mv x5, x6 devient addi x5, x6, 0. Le contrôle exact des instructions peut être utile dans le code du système d’exploitation et les boucles critiques, mais il sacrifie une partie de la portabilité et de la liberté d’optimisation du compilateur offertes par le code de haut niveau.

L’architecture du jeu d’instructions (ISA) est le contrat entre le matériel et les logiciels de plus bas niveau. Elle indique à la personne qui programme en langage machine quelles opérations existent et ce qu’elles signifient. La conception interne d’un processeur peut changer alors que ce contrat reste stable.

Ce que spécifie le contrat

Une ISA définit les instructions et leurs codages binaires, les registres visibles par le programmeur, le mode d’adressage, les types de données pris en charge et les mécanismes de l’architecture utilisés pour accéder aux entrées-sorties. Un compilateur cible ces caractéristiques lorsqu’il transforme un calcul en instructions.

Une implémentation est une conception matérielle qui respecte l’ISA. Sa microarchitecture décrit des choix internes comme les unités d’exécution, les étages du pipeline, la taille des caches et la prédiction des branchements. Ces choix influent fortement sur le temps d’exécution.

La distinction porte sur le comportement promis. Un programme doit recevoir le résultat de multiplication spécifié. Il n’a généralement pas besoin de savoir comment le multiplicateur a été construit pour obtenir ce résultat.

Pourquoi une ISA seule ne suffit pas à assurer la compatibilité binaire

L’interface binaire d’application (ABI) ajoute à l’ISA accessible aux programmes utilisateur l’interface du système d’exploitation et les conventions binaires. Elle spécifie les conventions d’appel, comme les registres d’arguments, ainsi que l’organisation des données et les conventions d’appel système. Deux machines peuvent exécuter les mêmes codages d’instructions tout en utilisant des règles différentes pour transmettre un argument à une fonction.

La compatibilité binaire exige la prise en charge des fonctionnalités de l’ISA et de l’ABI nécessaires au programme. Même au sein de la famille x86, qui a commencé avec l’Intel 8086 en 1978, la prise en charge par le système d’exploitation et les modes d’exécution comptent. La rétrocompatibilité a préservé de nombreux anciens programmes alors que les implémentations des processeurs ont changé, mais le partage d’un nom de famille ne garantit pas que chaque exécutable historique fonctionne dans tous les environnements.

Une architecture, de nombreuses implémentations

Intel et AMD implémentent x86-64 avec des conceptions internes différentes. Arm et RISC-V prennent également en charge des implémentations aux budgets de puissance et aux performances très différents. RISC-V a été créée à l’Université de Californie à Berkeley en 2010 et est une ISA ouverte et libre de redevances. Ses jeux de base pour les entiers comprennent RV32I et RV64I ; ses extensions standard comprennent M pour la multiplication et la division d’entiers, et F et D pour les opérations en virgule flottante.

Un programme qui utilise une extension facultative a besoin d’une implémentation qui la prend en charge. L’existence d’une base commune ne rend pas toutes les extensions universelles. L’exemple d’addition RISC-V illustre la même interface entre matériel et logiciel que dans Arm et x86, même si leurs instructions et leurs codages diffèrent.

Richesse des instructions et temps d’exécution

Une ISA peut exprimer davantage de travail dans une seule instruction, ce qui réduit le nombre d’instructions. Cette instruction peut aussi prendre plus de cycles ou exiger un cycle plus long. Le calcul pertinent est le produit complet :

Un jeu d’instructions plus riche ne suffit pas à déterminer quelle machine est la plus rapide. Une ISA commune ne garantit pas non plus une vitesse égale : des processeurs compatibles peuvent utiliser des horloges, des caches et des unités d’exécution différents pour produire les mêmes résultats requis.

Une personne qui attend la conversion d’un fichier souhaite un temps de réponse court. Un service qui traite de nombreuses conversions a aussi besoin d’un débit élevé. Ces mesures répondent à des questions différentes, même lorsqu’elles décrivent un même ordinateur.

Choisir la grandeur adaptée à la tâche

Le temps de réponse, aussi appelé temps d’exécution ou latence, s’étend du début à la fin de la tâche. Il comprend le calcul, les accès à la mémoire et au stockage, les entrées-sorties et l’activité pertinente du système d’exploitation. Si la tâche attend dans une file après sa soumission, cette attente contribue au temps de réponse pour l’utilisateur.

Le débit est le travail accompli par unité de temps. Il peut s’exprimer en requêtes par seconde ou en tâches par heure. Une machine peut terminer de nombreuses tâches par heure alors que chacune prend beaucoup de temps.

Ajouter des processeurs peut augmenter le débit en exécutant des tâches indépendantes simultanément. Cela ne raccourcit pas nécessairement le calcul propre à une tâche, même si cela peut réduire le temps d’attente d’un processeur libre. Un processeur plus rapide améliore souvent les deux mesures.

Comparer les performances dans le bon sens

Pour une même tâche, on définit :

Si A prend 10 s et B prend 15 s, la performance de A par rapport à celle de B est :

A est 1,5 fois plus rapide. La performance de B vaut deux tiers de celle de A. Place le temps d’exécution le plus long au-dessus du plus court pour indiquer combien de fois la machine la plus rapide est plus rapide.

Pour une amélioration, l’accélération est l’ancien temps divisé par le nouveau. Une compilation dont la durée passe de 60 s à 48 s a pour accélération :

Sa réduction de temps est de :

La performance a augmenté de 25 %, tandis que le temps a diminué de 20 %. Ces pourcentages utilisent des dénominateurs différents. Dire « 20 % plus rapide » peut masquer la grandeur qui a changé ; le rapport et les temps mesurés rendent l’affirmation claire.

Un débit égal peut masquer des attentes différentes

Un service qui traite 1 200 requêtes par minute fournit 20 requêtes par seconde. Ce débit peut provenir du traitement d’une requête toutes les 50 ms, chaque requête prenant 50 ms. Il peut aussi provenir du traitement de dix requêtes en parallèle, chacune prenant 500 ms : dix requêtes terminées toutes les demi-secondes donnent à nouveau 20 par seconde.

La seconde organisation a le même débit, mais un temps de traitement par requête dix fois plus long. Le seul résultat de débit ne permet pas de déterminer la latence subie par un utilisateur. Compare le même travail accompli, indique l’intervalle de temps et garde les unités lorsque tu passes des minutes aux secondes.

Un chronomètre mesure tout ce qui se passe entre le début et la fin. L’équation de performance du processeur mesure le travail du processeur. Distinguer ces deux points de vue évite d’attribuer à une amélioration du processeur la réduction d’un temps d’attente qu’elle ne peut pas supprimer.

Temps écoulé et temps processeur

Le temps écoulé, ou temps réel, comprend le calcul, l’attente de fichiers ou du réseau et les intervalles pendant lesquels d’autres processus s’exécutent. Le temps processeur enregistre le temps de processeur attribué à la tâche. Le temps processeur utilisateur correspond à l’exécution du code du programme ; le temps processeur système correspond à l’exécution du code du système d’exploitation pour son compte.

Supposons que la commande Unix time indique « real 2.50 s, user 1.80 s, sys 0.20 s. » Le programme a utilisé :

de temps processeur. Pour cet exemple de mesure à un seul thread, les 0,50 s restantes représentent le temps non comptabilisé comme temps d’exécution processeur, par exemple une attente ou une période pendant laquelle le programme n’est pas planifié. Si une amélioration du processeur divise par deux la partie correspondant au temps processeur tandis que l’attente reste fixe, le temps écoulé devient :

Diviser par deux la totalité des 2,50 s réduirait aussi à tort le temps d’attente. La performance du processeur se concentre souvent sur le temps utilisateur ; la performance du système est évaluée à partir du temps écoulé sous une charge système contrôlée.

Pour un programme parallèle, le temps processeur est additionné sur ses threads et ses cœurs. Quatre cœurs travaillant pendant la majeure partie d’une seconde peuvent produire 3,6 s de temps utilisateur pendant 1,0 s de temps écoulé. Dans ce cas, soustraire le temps processeur total du temps écoulé ne mesure pas l’attente.

La fréquence d’horloge est l’inverse de la période

Une horloge donne un rythme au matériel synchrone. La période d’horloge s’exprime en secondes par cycle ; la fréquence d’horloge en cycles par seconde :

À 4 GHz, la fréquence est de quatre milliards de cycles par seconde. Un cycle dure :

À 2,5 GHz, la période est de 400 ps. Dans l’autre sens, 312,5 ps par cycle donnent :

Les préfixes de temps et de fréquence utilisent des puissances décimales. Les préfixes binaires de mémoire utilisent des puissances de deux. Des notations comme « GB » sont parfois employées de manière approximative pour des quantités binaires ; vérifie donc leur sens avant de convertir une taille.

Interpréter une mesure comme le résultat d’une exécution

La fréquence annoncée d’un processeur ne rend pas compte de chaque instant de son exécution. L’augmentation temporaire de fréquence, la gestion de l’énergie et le bridage thermique modifient la fréquence. Le contenu des caches et l’activité en arrière-plan modifient aussi le temps mesuré. Répéter une mesure et indiquer une valeur typique, comme la médiane, aide à distinguer un résultat stable d’une exécution exceptionnellement favorable. Utilise les mesures de temps et de fréquence du même intervalle d’exécution lorsque tu les relies au nombre de cycles.

Un cycle d’horloge est une unité de temps du processeur, pas une instruction. Certaines instructions nécessitent de nombreux cycles, et le chevauchement de leur exécution peut permettre d’en terminer plusieurs par cycle. Commence par le nombre total de cycles nécessaires à l’ensemble du programme.

Diviser les cycles par les cycles par seconde

Si le nombre de cycles nécessaires à un programme est connu, son temps processeur est :

Pour six milliards de cycles à 3 GHz :

Les unités expliquent la division : les cycles divisés par les cycles par seconde donnent des secondes. Multiplier les cycles par la fréquence produirait des cycles au carré par seconde, pas une durée. La multiplication par la période fonctionne parce que son unité est la seconde par cycle.

La même équation permet de trouver une autre inconnue. Multiplie le temps par la fréquence pour retrouver les cycles ; divise les cycles par le temps visé pour trouver la fréquence nécessaire. Garde la fréquence en Hz lorsque le temps est en secondes, ou simplifie explicitement les facteurs correspondants de l’ordre du milliard.

Quand une horloge plus rapide nécessite davantage de cycles

Le processeur A exécute un programme en 10 s à 3 GHz. Son budget de cycles est :

Une conception B proposée augmente ce nombre de cycles de 20 %. B doit donc exécuter :

Pour terminer en 9 s, B nécessite :

Le rapport des fréquences d’horloge est de quatre tiers, soit environ 1,33. L’accélération réelle n’est que de dix neuvièmes, soit environ 1,11, car B a besoin de plus de cycles pour terminer le travail. Supposer que l’ancien nombre de cycles reste inchangé conduirait à prévoir une fréquence d’horloge trop basse pour atteindre l’objectif.

Comparer un compromis sans choisir une taille de programme

Supposons qu’une conception multiplie l’ancien nombre de cycles par un facteur $a$ et l’ancienne fréquence d’horloge par un facteur $b$. Alors :

La conception est plus rapide lorsque le facteur d’augmentation du nombre de cycles est inférieur au facteur d’augmentation de la fréquence. Si les deux augmentent du même facteur, le temps processeur reste inchangé. Ce rapport est utile lorsqu’une proposition de conception indique des changements en pourcentage sans donner de nombre absolu de cycles.

Pourquoi la période a une limite physique

Entre les registres, les signaux traversent la logique combinatoire et doivent se stabiliser avant que leurs résultats soient enregistrés. Le chemin nécessaire le plus lent est le chemin critique. La technologie des circuits et la quantité de travail attribuée à un étage limitent la réduction possible de la période d’horloge sans compromettre le fonctionnement.

Un concepteur peut diviser le travail en étages de pipeline plus courts pour permettre une horloge plus rapide, mais cette réorganisation peut aussi modifier le nombre de cycles. Davantage de GHz indique donc une fréquence d’horloge plus élevée. Pour établir une amélioration de performance, associe cette fréquence au nombre de cycles dont le programme a réellement besoin avec cette conception.

Le nombre de cycles par instruction (CPI) est le nombre total de cycles processeur du programme divisé par son nombre d’instructions exécutées. C’est une moyenne sur une exécution : il peut donc être fractionnaire et dépend des instructions exécutées et de leurs interactions avec la machine.

Additionner les cycles avant de calculer la moyenne

Pour des classes d’instructions d’effectifs $C_i$ et de CPI par classe $c_i$ :

De façon équivalente, multiplie le CPI de chaque classe par sa proportion dans le nombre d’instructions et additionne les contributions. Les proportions doivent porter sur les instructions exécutées, pas sur les lignes source ou le nombre de types d’instructions.

Supposons que les instructions de l’unité arithmétique et logique prennent 1 cycle, les chargements et rangements 4, et les branchements 2. Une répartition de 50 %, 30 % et 20 % donne :

Pour cinq milliards d’instructions à 3 GHz, le total est de 10,5 milliards de cycles et le temps processeur de 3,5 s. La moyenne non pondérée des coûts des trois classes, environ 2,33, est incorrecte : les classes n’apparaissent pas aussi souvent les unes que les autres.

Davantage d’instructions peuvent tout de même nécessiter moins de cycles

Deux versions d’un compilateur utilisent les mêmes coûts par classe :

La version 1 exécute 800 millions d’instructions. Les contributions en cycles sont de 400, 1 200 et 200 millions, soit un total de 1 800 millions. Son CPI est :

La version 2 exécute 850 millions d’instructions. Ses contributions sont de 600, 600 et 200 millions, soit un total de 1 400 millions. Son CPI est :

À 3 GHz, les temps sont de 0,60 s et d’environ 0,467 s. La version 2 est environ 1,29 fois plus rapide malgré l’exécution de 50 millions d’instructions supplémentaires. Remplacer de nombreuses instructions mémoire coûteuses par un plus grand nombre d’instructions peu coûteuses pour l’unité arithmétique et logique peut rendre ce compromis avantageux.

Le CPI caractérise une charge de travail sur une machine

Les attentes mémoire, les défauts de cache, le comportement des branchements et les choix du compilateur modifient le CPI effectif. Un seul « CPI du processeur » ne peut pas décrire tous les programmes. Des compteurs de performance matériels ou un simulateur peuvent mesurer les nombres totaux d’instructions et de cycles pour la charge de travail analysée.

Le nombre d’instructions par cycle (IPC) utilise les mêmes totaux dans l’ordre inverse :

Un IPC de 2,5 donne un CPI de 0,4. Plusieurs instructions peuvent se chevaucher dans un processeur qui émet et termine plusieurs instructions par cycle. Une moyenne inférieure à un ne signifie pas que le parcours complet d’une instruction individuelle s’achève en une fraction de cycle d’horloge.

L’équation de performance du processeur réunit les trois facteurs du temps d’exécution :

Ici, $I$ est le nombre d’instructions exécutées et $f$ la fréquence d’horloge effective pendant l’exécution. Le nombre d’instructions multiplié par les cycles par instruction donne les cycles. La division par les cycles par seconde donne ensuite des secondes.

Calculer un temps et retrouver une inconnue

Un programme exécute deux milliards d’instructions avec un CPI de 1,5 sur un processeur à 2,5 GHz. Calcule d’abord le nombre total de cycles, puis convertis-le en temps :

Pour déduire le CPI du temps mesuré, transforme la même équation :

Pour 1,6 milliard d’instructions en 0,8 s à 3,2 GHz, on obtient 2,56 milliards de cycles. La division par 1,6 milliard d’instructions donne un CPI de 1,6.

Comparer les produits complets

Deux processeurs exécutent le même programme compilé avec le même nombre d’instructions. A a une fréquence de 4 GHz et un CPI de 1,8 ; B a une fréquence de 2,5 GHz et un CPI de 1,0. Leurs temps par instruction sont :

B est 1,125 fois plus rapide. Son CPI plus faible compense largement son horloge plus lente. Le nombre d’instructions se simplifie ici parce qu’il est identique ; il ne se simplifierait pas si les deux programmes suivaient des séquences d’instructions différentes.

De même, une option du compilateur qui réduit le nombre d’instructions de 10 % mais augmente le CPI de 15 %, à fréquence identique, modifie le temps d’un facteur :

Le temps augmente de 3,5 %. La seule réduction du nombre d’instructions indique une évolution dans le mauvais sens.

Relier les choix de conception aux facteurs

Ces liens sont utiles pour l’analyse ; ce ne sont pas des réglages indépendants que l’on peut toujours modifier sans conséquence. Un cache réduit les cycles d’attente de la mémoire, ce qui abaisse le CPI effectif. L’exécution en pipeline fait se chevaucher des instructions successives et peut réduire le CPI effectif ou permettre une période d’horloge plus courte. Ces changements peuvent introduire d’autres coûts qui apparaissent dans les totaux mesurés.

Garder un intervalle de mesure cohérent

Mesure le temps processeur, le nombre d’instructions, les cycles et la fréquence pour le même travail. Des compteurs ou une simulation fournissent les nombres d’instructions et de cycles. La fréquence nominale en GHz d’un produit ne retrace pas la fréquence d’une exécution pendant laquelle le processeur accélère ou ralentit. Lorsque la fréquence varie, la moyenne correspondante est le nombre total de cycles comptés divisé par le temps processeur de cet intervalle.

L’équation prévoit le temps d’exécution processeur. L’attente du stockage ou du réseau fait partie du temps écoulé et doit être ajoutée séparément lorsque c’est le résultat dont l’utilisateur a besoin.

Une affirmation utile sur la performance porte sur un travail qui compte pour l’utilisateur. Un programme de test de performance exécute une charge de travail choisie pour mesurer la performance. Une batterie de tests de performance échantillonne plusieurs charges de travail lorsqu’une seule application ne peut pas représenter l’ensemble du besoin.

Lire le type de résultat SPEC

SPEC CPU 2026, publiée en mai 2026, succède à SPEC CPU 2017. Ses batteries sollicitent les processeurs, les systèmes mémoire et les compilateurs. SPECspeed mesure le temps nécessaire pour terminer un exemplaire d’un programme ; cet exemplaire peut lui-même utiliser plusieurs threads. SPECrate mesure le débit à l’aide de plusieurs exemplaires. Les batteries pour les entiers et pour la virgule flottante répondent à différents types de charges de travail, et le produit prend aussi en charge des mesures énergétiques.

Un rapport de vitesse pour un programme compare le temps de référence au temps mesuré :

Un temps de référence de 3 000 s et un temps mesuré de 250 s donnent 12. Plus le résultat est élevé, mieux c’est. Un rapport de débit comprend le nombre d’exemplaires terminés pendant l’intervalle mesuré. Compare des indicateurs de même type et la même version de la batterie ; un score de vitesse et un score de débit répondent à des questions différentes.

Synthétiser les rapports avec une moyenne géométrique

Pour des rapports positifs, la batterie utilise :

Les rapports 2, 8 et 4 donnent un produit de 64 et une racine cubique de 4. Leur moyenne arithmétique est d’environ 4,67, ce qui donne un résultat différent.

La comparaison par la moyenne géométrique ne dépend pas de la machine de référence choisie pour établir les rapports. Supposons que X prenne 10 s et 40 s sur deux programmes, tandis que Y prend 20 s et 25 s. Des temps de référence de 100 s pour les deux donnent des rapports de 10 et 2,5 pour X, et de 5 et 4 pour Y. Les moyennes géométriques sont de 5 et d’environ 4,47 : X est donc en tête avec un facteur d’environ 1,12.

Remplaçons les temps de référence par 50 s et 200 s : X obtient des rapports de 5 et 5, Y de 2,5 et 8. Leurs moyennes géométriques restent de 5 et d’environ 4,47. Les moyennes arithmétiques passent en revanche de 6,25 contre 4,5 à 5 contre 5,25, ce qui inverse le classement. La normalisation par rapport à la référence ne doit pas déterminer quelle machine semble la plus rapide.

Pourquoi les MIPS peuvent favoriser un code plus lent

Les MIPS, millions d’instructions par seconde, sont définis par :

Les instructions accomplissent des quantités différentes de travail utile selon les ISA. Même sur une seule machine, les MIPS changent selon le programme, et un débit d’instructions plus élevé peut s’accompagner d’un temps d’exécution plus long.

À 3 GHz, supposons que les instructions de l’unité arithmétique et logique, les chargements et rangements et les branchements coûtent respectivement 1, 4 et 2 cycles. Le code Q en exécute respectivement 400, 300 et 100 millions : 800 millions d’instructions, 1 800 millions de cycles, 0,60 s, environ 1 333 MIPS. Le code P en exécute 1 500, 100 et 100 millions : 1 700 millions d’instructions, 2 100 millions de cycles, 0,70 s, environ 2 429 MIPS. P termine ses instructions plus rapidement mais achève la tâche plus tard.

Les débits de crête décrivent la capacité idéale du matériel. Les charges de travail réelles peuvent atteindre beaucoup moins en raison des dépendances, des attentes mémoire et d’autres limites. Utilise le temps réel d’une tâche pour juger sa performance ; la fréquence, les MIPS et les débits de crête n’en expliquent que certaines parties.

La loi d’Amdahl commence par diviser le temps d’exécution initial en une partie concernée et une partie non concernée. Accélère uniquement le temps de la partie concernée, puis additionne à nouveau les deux parties. Cela évite d’appliquer une amélioration locale à un travail qu’elle ne peut pas modifier.

Construire le nouveau temps à partir des anciens temps

Si la partie concernée devient $s$ fois plus rapide :

Soit $f$ la fraction concernée du temps d’exécution initial. La division par le temps initial donne la formule de l’accélération :

Un programme de 120 s passe 90 s à effectuer des calculs en virgule flottante et 30 s ailleurs. La fraction concernée est donc de 0,75. Rendre les calculs en virgule flottante trois fois plus rapides réduit leur temps à 30 s :

Les calculs en virgule flottante gagnent un facteur trois ; le programme complet gagne un facteur deux. Les 30 s inchangées expliquent l’écart.

Remonter à partir d’un objectif

Pour terminer la même tâche en 40 s, le travail inchangé nécessite toujours 30 s. Il ne reste que 10 s pour la partie en virgule flottante qui prenait initialement 90 s. Donc :

Un objectif de 30 s laisserait zéro temps pour ce travail. Aucune accélération finie ne permet à une quantité positive de travail concerné de prendre exactement zéro temps. Lorsque l’accélération locale augmente sans borne, l’accélération globale tend vers :

Ici, la limite est de 4, approchée par valeurs inférieures. Avec une fraction non concernée d’une moitié, la limite est de 2. Lorsque tout le travail est concerné, aucun temps positif inchangé n’impose un tel plafond fini.

Optimiser ce qui prend du temps

Le principe accélérer le cas courant consiste à repérer où le temps d’exécution est réellement passé. Le profilage mesure cette répartition. Doubler la vitesse d’une partie responsable de 60 % du temps donne :

Une amélioration d’un facteur dix sur une partie de 10 % ne donne que :

Un facteur local élevé peut apporter moins qu’une amélioration modeste appliquée à une plus grande partie de la tâche.

La fraction concernée doit être une fraction du temps. Si les chargements et rangements représentent 30 % des instructions mais prennent 60 % des cycles, leur fraction du temps à fréquence d’horloge fixe est de 0,60. Compter toutes les instructions de la même façon masquerait leur coût plus élevé.

Appliquer la même répartition à l’attente

Pour une tâche avec 2,00 s de travail processeur et 0,50 s d’attente fixe de fichiers, doubler la vitesse du processeur donne 1,50 s au total. L’accélération est d’environ 1,67. Le même budget de temps s’applique aux améliorations du matériel, des logiciels et des entrées-sorties : détermine exactement quelle partie du temps initial change avant d’appliquer le facteur.

Des cœurs supplémentaires ne raccourcissent une tâche que si du travail peut s’exécuter simultanément. Divise le temps initial d’une tâche fixe sur un seul cœur en une partie séquentielle et une partie parallèle, puis examine ce que des cœurs supplémentaires peuvent changer.

La loi d’Amdahl pour une tâche de taille fixe

Soit $p$ la fraction parallèle du temps initial sur un seul cœur. Avec une répartition parfaite sur $N$ cœurs et sans surcoût :

Pour une fraction parallèle de 0,95, la fraction séquentielle est de 0,05. Huit cœurs donnent :

À 100 cœurs, l’accélération est d’environ 16,8 ; à 1 000 cœurs, elle est d’environ 19,6. Les 5 % séquentiels maintiennent l’accélération pour une taille fixe sous 20, quel que soit le nombre de cœurs ajoutés.

L’efficacité parallèle est l’accélération divisée par le nombre de cœurs. L’efficacité sur huit cœurs est d’environ 0,74, soit 74 %. À 100 cœurs, elle est d’environ 17 %. Une accélération plus élevée peut s’accompagner d’une efficacité plus faible, car chaque cœur supplémentaire contribue moins à la tâche fixe.

Pourquoi les gains mesurés peuvent être plus faibles

Le modèle idéal répartit le travail parallèle en parts égales et ne prévoit aucun coût de coordination. Les programmes réels communiquent et se synchronisent, et certains cœurs reçoivent plus de travail que d’autres.

Pour 100 unités égales de travail indépendant sur quatre cœurs identiques, une affectation équilibrée donne 25 unités à chacun. Si l’un reçoit 40 unités tandis que les autres terminent plus tôt, la fin de la tâche attend ce cœur le plus chargé. L’accélération est de 100 divisé par 40, soit 2,5, avant même d’ajouter les coûts de communication. Additionner les temps de fin anticipée des autres cœurs ne donnerait pas le temps nécessaire pour terminer : c’est le dernier résultat requis qui le détermine.

Un programme à un seul thread n’a aucune fraction parallèle à répartir. Des cœurs supplémentaires peuvent tout de même exécuter d’autres programmes et améliorer le débit du système, mais ils ne divisent pas automatiquement le flux d’instructions de ce programme.

Travail fixe et travail croissant posent des questions différentes

Le passage à l’échelle fort (strong scaling) maintient la taille totale du problème fixe et cherche à savoir combien de fois des processeurs supplémentaires peuvent le terminer plus vite. Le passage à l’échelle faible (weak scaling) augmente le travail total proportionnellement au nombre de processeurs, de sorte que le travail par processeur reste à peu près constant. Une simulation plus grande peut utiliser une grille plus fine tout en gardant à peu près la même charge de travail par processeur.

La loi de Gustafson décrit le travail agrandi lorsque le temps séquentiel reste fixe tandis que le travail parallèle augmente. Sa fraction séquentielle $s$ est mesurée lors de l’exécution parallèle, contrairement à la fraction initiale sur un cœur de la loi d’Amdahl :

Pour une fraction séquentielle mesurée de 0,05 sur 100 cœurs, l’accélération pour le problème agrandi est de 95,05. Cela ne contredit pas la limite d’Amdahl de 20 pour une tâche fixe dont la fraction séquentielle initiale était de 5 %. La taille de la tâche et la base de mesure de la fraction diffèrent.

Un logiciel parallèle doit mettre à disposition du travail indépendant, l’équilibrer et coordonner les résultats. Le matériel supplémentaire fournit de la capacité ; la structure du programme détermine dans quelle mesure cette capacité raccourcit son temps d’exécution.

Les processeurs CMOS consomment de l’énergie lors de la commutation des signaux et aussi par les fuites lorsqu’ils sont alimentés. L’énergie dynamique est associée à la commutation ; la puissance statique est consommée même sans commutation utile. Leurs parts relatives dépendent de la puce et de sa charge de travail.

La tension a un effet au carré

L’énergie associée à une transition varie proportionnellement à la capacité et au carré de la tension d’alimentation. Une expression courante utilise la moitié de la capacité multipliée par la tension au carré ; une impulsion complète de charge et de décharge varie proportionnellement à la capacité multipliée par la tension au carré. Pour la puissance dynamique moyenne, utilise :

Ici, $C$ est la charge capacitive, $V$ la tension d’alimentation, $f$ la fréquence d’horloge et $\alpha$ décrit l’activité de commutation selon la convention de comptage choisie. Certaines conventions incluent un facteur d’une moitié dans le facteur d’activité. Les calculs de rapports fonctionnent correctement lorsque la convention d’activité reste cohérente.

À capacité et activité inchangées, réduire la tension et la fréquence de 20 % chacune donne :

La nouvelle puissance dynamique représente 51,2 % de la puissance initiale. Réduire la tension seule de 10 % donne un facteur de 0,81, soit une réduction de 19 % de la puissance dynamique et de l’énergie par transition.

Une tension plus faible ralentit aussi la commutation des transistors. L’adaptation dynamique de la tension et de la fréquence (DVFS) ajuste la tension et la fréquence ensemble pour que les circuits puissent toujours fonctionner à la vitesse choisie.

Puissance et énergie répondent à des questions différentes

La puissance est un débit d’énergie mesuré en watts ; un watt correspond à un joule par seconde. L’énergie d’une tâche est la puissance moyenne multipliée par la durée :

B consomme plus de puissance pendant son exécution mais moins d’énergie pour terminer la tâche. Le refroidissement doit gérer la vitesse de production de chaleur ; l’utilisation de la batterie et la consommation d’électricité accumulent de l’énergie au fil du temps.

Pour un travail fixe avec les mêmes nombre de transitions, tension et activité, réduire la fréquence seule répartit ces transitions sur une durée plus longue. La puissance dynamique diminue, mais l’énergie dynamique de la tâche reste inchangée. Réduire la tension diminue aussi l’énergie de chaque transition. Si la puissance statique persiste pendant toute l’exécution prolongée, le ralentissement peut même augmenter cette partie de l’énergie de la tâche.

Fuites et matériel inactif

Les transistors censés être bloqués laissent tout de même passer un courant de fuite. Les dispositifs plus petits et les tensions de seuil plus faibles font des fuites un enjeu important de conception. La coupure d’alimentation déconnecte l’alimentation d’une zone inactive pour réduire sa consommation statique.

Un serveur peu chargé peut tout de même consommer une part importante de sa puissance de crête. Faire suivre la consommation au travail utile, ce qu’on appelle la proportionnalité énergétique, est un objectif de conception. Terminer rapidement une tâche et passer à un état de faible consommation peut économiser de l’énergie en raccourcissant l’intervalle pendant lequel les fuites et les autres consommations de fond persistent. La performance et l’efficacité énergétique peuvent donc s’améliorer ensemble.

Pendant des décennies, des transistors plus petits ont permis d’obtenir davantage de dispositifs et une commutation plus rapide tout en maintenant la chaleur à un niveau maîtrisable. Le mur de puissance est apparu lorsque la tension ne pouvait plus diminuer suffisamment pour maintenir cette tendance. Il a changé la façon dont les concepteurs transformaient de nouveaux transistors en performance utile.

La relation idéale de la loi de Dennard

Dans le modèle idéal de réduction développé par Robert Dennard et ses collègues en 1974, soit un facteur $k>1$ qui décrit la réduction. Les dimensions, la capacité, la tension et le délai sont divisés par ce facteur. La fréquence peut être multipliée par ce facteur. La puissance dynamique par transistor change donc selon :

La surface par transistor diminue aussi du carré du facteur de réduction. La même surface peut accueillir autant de transistors supplémentaires, ce qui compense la puissance plus faible de chaque dispositif. La densité de puissance, en watts par unité de surface, reste à peu près constante dans ce modèle idéal.

Pour un facteur de 1,4, la capacité et la tension tombent à environ 0,71 de leurs valeurs initiales et la fréquence augmente d’un facteur 1,4. La puissance par transistor tombe à environ 0,51. Il est possible de placer environ 1,96 fois plus de transistors, de sorte que la puissance totale sur une même surface reste à peu près inchangée.

Pourquoi la tension a cessé de suivre la taille

Les transistors ont besoin d’un seuil de commutation utilisable. Réduire trop fortement la tension de seuil augmente fortement les fuites. Au milieu des années 2000, la tension d’alimentation ne pouvait plus diminuer au même rythme que les dimensions des transistors. À tension presque fixe, une fréquence plus élevée augmente la puissance dynamique, et placer davantage de transistors actifs sur une surface augmente la chaleur à évacuer.

Les chiffres historiques montrent l’ampleur du changement antérieur : les fréquences des ordinateurs de bureau sont passées d’environ 10 MHz au début des années 1980 à 3,8 GHz en 2004, tandis que les tensions d’alimentation passaient d’environ 5 V vers 1 V. Ce sont des valeurs historiques générales, pas des spécifications universelles. Environ 100 W représentait déjà un budget de refroidissement difficile à gérer pour de nombreuses conceptions grand public de l’époque.

L’annulation en 2004 par Intel du Pentium 4 à 4 GHz prévu et de la conception Tejas a marqué ce tournant vers des conceptions attentives à la puissance et vers les processeurs à deux cœurs. Les fréquences d’horloge sont ensuite restées de l’ordre de quelques gigahertz au lieu de poursuivre leur hausse rapide antérieure. La microarchitecture a continué à améliorer la performance d’un seul cœur, mais les augmentations de fréquence ont apporté une part bien plus faible du gain.

Gérer le budget thermique

L’enveloppe thermique (TDP) est une cible de conception thermique utilisée pour dimensionner une solution de refroidissement dans des conditions de fonctionnement spécifiées. Ce n’est ni une mesure de puissance instantanée ni un maximum universel. Lorsque les limites thermiques sont atteintes, le bridage thermique réduit la vitesse de fonctionnement pour diminuer la chaleur.

Si une puce contient plus de matériel que son budget de puissance ne permet d’en faire fonctionner ensemble à pleine vitesse, certaines zones doivent être ralenties ou éteintes. Le silicium noir désigne cet écart entre les transistors disponibles et le matériel actif utilisable simultanément.

La loi de Moore et la loi de Dennard décrivent des tendances différentes : le nombre de transistors pour l’une, les effets d’une réduction tenant compte de la puissance pour l’autre. La fin de la validité de la seconde ne signifiait pas que le nombre de transistors avait cessé d’augmenter. L’obstacle à l’augmentation indéfinie de la fréquence est principalement la puissance et la chaleur, et non une incapacité soudaine des transistors à commuter plus vite.

Un processeur multicœur place plusieurs cœurs sur une même puce. Chaque cœur exécute un flux d’instructions, tandis que les cœurs partagent la mémoire principale et souvent certains caches. Les conceptions grand public d’ordinateurs de bureau et portables se sont orientées vers deux cœurs vers 2005-2006, car augmenter la fréquence d’un seul cœur devenait de plus en plus coûteux en puissance.

Comparer deux cœurs plus lents à un cœur plus rapide

Considère un cœur à 4 GHz et 1,2 V contre deux cœurs à 3 GHz et 1,0 V. Pour cette comparaison, garde la même capacité par cœur et la même activité de commutation. La puissance dynamique relative est :

Avec un travail égal par cycle et suffisamment de travail indépendant pour les deux cœurs, le débit idéal change d’un facteur :

La paire offre environ 50 % de débit en plus pour environ 4 % de puissance dynamique en plus. Dans ce modèle, l’effet au carré de la réduction de tension rend le cœur supplémentaire possible. La puissance statique, les limites de la mémoire partagée et les coûts de coordination comptent toujours pour évaluer une puce complète.

Pour un programme séquentiel qui n’utilise qu’un seul nouveau cœur, la performance tombe aux trois quarts de la performance initiale à travail égal par cycle. Il prend quatre tiers du temps initial. Additionner les deux fréquences de 3 GHz pour obtenir « 6 GHz » masquerait ce résultat : aucun des deux cœurs ne fonctionne à 6 GHz.

Le logiciel doit rendre le travail parallélisable

Avant le mur de puissance, une fréquence plus élevée et le chevauchement matériel accéléraient souvent le code existant sans changements majeurs. Les cœurs supplémentaires ont besoin de flux d’instructions indépendants. Un programme en profite en divisant son travail en tâches concurrentes, en équilibrant les affectations et en coordonnant les résultats. Les bibliothèques parallèles peuvent fournir cette structure, mais le travail doit tout de même se prêter utilement au parallélisme.

Le parallélisme au niveau des instructions fait se chevaucher des instructions au sein d’un flux, grâce à des techniques matérielles et de compilation comme l’exécution en pipeline et l’émission multiple. Le parallélisme au niveau des threads exécute différents threads sur plusieurs cœurs. Ce sont deux sources différentes de concurrence : la première ne garantit pas qu’un programme puisse occuper tous les cœurs.

Les requêtes indépendantes d’un serveur fournissent naturellement de nombreux flux ; le multicœur peut donc améliorer le débit même lorsque chaque requête reste séquentielle. Raccourcir le calcul d’une requête exige du parallélisme au sein de cette requête. Sa fraction séquentielle impose alors la limite d’Amdahl.

Consacrer les transistors à des travaux efficaces

Davantage de transistors peuvent servir à créer des caches plus grands, plusieurs cœurs généralistes ou du matériel spécialisé. Les GPU et les accélérateurs spécialisés ciblent des charges de travail comme le graphisme, l’apprentissage automatique et l’encodage vidéo. Les puces peuvent aussi combiner des cœurs rapides et gourmands en puissance avec des cœurs plus petits et plus efficaces, comme dans les conceptions big.LITTLE d’Arm.

Avec un budget de puissance fixe, la performance par watt compare la performance utile à la puissance consommée. SPEC CPU 2026 prend aussi en charge des mesures énergétiques en plus des mesures de performance. Une bonne décision de conception tient compte du temps nécessaire pour terminer la charge de travail, de son coût énergétique et de la puissance que le système peut soutenir.