L'unité centrale de traitement (CPU), également appelée processeur central, processeur principal ou simplement processeur, fonctionne comme le processeur principal au sein d'un système informatique. Ses circuits électroniques sont chargés d'exécuter les instructions d'un programme informatique, englobant des opérations telles que l'arithmétique, la logique, le contrôle et les entrées/sorties (E/S). Cette fonction distingue le processeur des éléments externes tels que la mémoire principale et les circuits d'E/S, ainsi que des coprocesseurs spécialisés tels que les unités de traitement graphique (GPU).
Bien que la forme, la conception et la mise en œuvre des unités centrales de traitement aient considérablement évolué, leurs principes de fonctionnement fondamentaux ont largement persisté. Les composants clés d'un processeur comprennent l'unité arithmétique-logique (ALU), qui exécute les opérations arithmétiques et logiques ; des registres de processeur, qui fournissent des opérandes à l'ALU et conservent les résultats des opérations ; et une unité de contrôle, qui gère la récupération, le décodage et l'exécution des instructions en coordonnant l'ALU, les registres et d'autres composants internes. Les processeurs contemporains allouent un espace semi-conducteur substantiel aux caches et au parallélisme au niveau des instructions pour améliorer les performances, ainsi qu'aux modes CPU pour prendre en charge les systèmes d'exploitation et les capacités de virtualisation.
La majorité des processeurs contemporains sont fabriqués sous forme de microprocesseurs à circuits intégrés (CI), dans lesquels un ou plusieurs processeurs résident sur une seule puce IC. Les puces de microprocesseur intégrant plusieurs processeurs sont désignées sous le nom de processeurs multicœurs (MCP). Ces processeurs physiques distincts, appelés cœurs de processeur, sont également capables d'effectuer du multithreading pour faciliter le multithreading au niveau du processeur.
Un circuit intégré (CI) hébergeant un processeur peut en outre intégrer de la mémoire, des interfaces périphériques et d'autres composants informatiques. De tels dispositifs intégrés sont communément appelés microcontrôleurs ou systèmes sur puce (SoC).
Historique
Les premières machines informatiques, illustrées par l'ENIAC, nécessitaient un recâblage physique pour chaque tâche distincte, ce qui a conduit à leur classification comme « ordinateurs à programme fixe ». La désignation « unité centrale de traitement » est utilisée depuis au moins 1955. Étant donné que « CPU » est généralement défini comme un mécanisme d'exécution de logiciels (programmes informatiques), les premiers dispositifs appelés à juste titre CPU sont apparus en même temps que le développement de l'ordinateur à programme stocké.
Le concept d'ordinateur à programme stocké était déjà inhérent à la conception de l'ENIAC de John Presper Eckert et John William Mauchly, bien qu'il ait été initialement exclu pour accélérer l'achèvement. Le 30 juin 1945, avant la construction de l'ENIAC, le mathématicien John von Neumann fit circuler un document intitulé Première ébauche d'un rapport sur l'EDVAC. Cet article détaillait l'architecture d'un ordinateur à programme stocké, qui fut ensuite finalisé en août 1949. L'EDVAC a été conçu pour exécuter un ensemble prédéfini d'instructions ou d'opérations diverses. Fondamentalement, les programmes de l'EDVAC étaient destinés à résider dans la mémoire de l'ordinateur à haute vitesse, plutôt que d'être dictés par le câblage physique de la machine. Cette innovation a résolu un inconvénient important de l'ENIAC, à savoir le temps et les efforts considérables nécessaires pour le reconfigurer pour de nouvelles tâches. La conception de Von Neumann a permis la modification du programme de l'EDVAC simplement en modifiant le contenu de la mémoire. Cependant, EDVAC n'était pas le pionnier des ordinateurs à programme stocké ; le Manchester Baby, un ordinateur expérimental à programme stocké à petite échelle, a exécuté son programme initial le 21 juin 1948, suivi du Manchester Mark 1, qui a exécuté son premier programme dans la nuit du 16 au 17 juin 1949.
Au départ, les processeurs étaient des composants personnalisés intégrés dans des systèmes informatiques plus grands, souvent uniques. Néanmoins, cette approche consistant à développer des processeurs sur mesure pour des applications spécifiques a été largement remplacée par la production en série de processeurs polyvalents. Cette tendance à la normalisation a débuté à l'époque des ordinateurs centraux et des mini-ordinateurs à transistors discrets, et s'est considérablement intensifiée avec l'adoption généralisée du circuit intégré (CI). Le circuit intégré a facilité la conception et la fabrication de processeurs de plus en plus complexes avec des tolérances à l'échelle nanométrique. Les effets combinés de la miniaturisation et de la standardisation des processeurs ont considérablement accru l’omniprésence des appareils numériques dans la société contemporaine, allant bien au-delà du cadre limité des machines informatiques spécialisées. Les microprocesseurs modernes sont désormais présents dans un large éventail d'appareils électroniques, depuis les automobiles et les téléphones portables jusqu'aux articles récréatifs comme les jouets.
Bien que John von Neumann soit largement reconnu pour avoir conçu l'ordinateur à programme stocké à travers sa conception EDVAC, qui est ensuite devenue connue sous le nom d'architecture von Neumann, des innovateurs antérieurs comme Konrad Zuse avaient proposé et actualisé des concepts comparables. Le Harvard Mark I, achevé avant EDVAC, utilisait également une architecture de programme stocké, appelée architecture Harvard, utilisant une bande de papier perforée au lieu d'une mémoire électronique. Une distinction fondamentale entre ces deux architectures réside dans la séparation du stockage et du traitement de l'architecture Harvard pour les instructions et les données du processeur, contrastant avec l'utilisation par l'architecture von Neumann d'un espace mémoire unifié pour les deux. Alors que la plupart des processeurs contemporains adhèrent principalement à la conception de von Neumann, les processeurs d'architecture Harvard sont également répandus, en particulier dans les systèmes embarqués, illustrés par les microcontrôleurs Atmel AVR.
Avant l'avènement du transistor, les relais et les tubes à vide (également appelés tubes thermoioniques) constituaient les principaux éléments de commutation dans les ordinateurs, les systèmes fonctionnels nécessitant des milliers ou des dizaines de milliers de tels dispositifs. Les performances du système étaient directement corrélées à la vitesse de fonctionnement de ces commutateurs. Les ordinateurs à tubes sous vide, comme EDVAC, connaissaient généralement des pannes toutes les huit heures environ, tandis que les ordinateurs basés sur des relais, tels que le Harvard Mark I, plus lent mais plus ancien, démontraient une fiabilité nettement supérieure. En fin de compte, les unités centrales de traitement (CPU) à tubes ont gagné en importance parce que leurs avantages substantiels en termes de vitesse ont généralement remplacé leurs problèmes de fiabilité inhérents. La plupart de ces premiers processeurs synchrones fonctionnaient à des fréquences d'horloge considérablement inférieures à celles des conceptions microélectroniques modernes, avec des fréquences de signal d'horloge typiques allant de 100 kHz à 4 MHz, principalement contraintes par les limitations de vitesse de leurs dispositifs de commutation constitutifs.
Unités centrales de traitement basées sur des transistors
La complexité architecturale des unités centrales de traitement (CPU) s'est progressivement intensifiée à mesure que les progrès technologiques permettaient la création de composants électroniques plus compacts et plus fiables. L’introduction du transistor a été un développement crucial dans cette trajectoire. Les processeurs à transistors, apparus dans les années 1950 et 1960, ont évité le besoin d'éléments de commutation encombrants, peu fiables et délicats tels que des tubes à vide et des relais. Cette innovation a facilité la construction de processeurs plus complexes et plus robustes, souvent intégrés sur une ou plusieurs cartes de circuits imprimés utilisant des composants discrets (individuels).
En 1964, IBM a dévoilé son architecture informatique System/360, qui sous-tendait une famille d'ordinateurs capables d'exécuter des programmes identiques à différentes vitesses et niveaux de performances. Cela représentait une avancée significative, étant donné que la plupart des ordinateurs électroniques de l’époque, même ceux du même fabricant, étaient largement incompatibles. Pour réaliser cette interopérabilité, IBM a mis en œuvre le concept de microprogramme, fréquemment appelé « microcode », une technique qui reste largement utilisée dans les processeurs contemporains. L'architecture System/360 a acquis une immense popularité, dominant le marché des ordinateurs centraux pendant des décennies et établissant un héritage durable perpétué par des systèmes modernes tels que l'IBM zSeries. Par la suite, en 1965, Digital Equipment Corporation (DEC) a introduit un autre ordinateur percutant, le PDP-8, ciblant spécifiquement les applications scientifiques et de recherche.
Les ordinateurs à transistors offraient plusieurs avantages notables par rapport à leurs prédécesseurs. En plus d'améliorer la fiabilité et de réduire la consommation d'énergie, les transistors ont permis aux processeurs d'atteindre des vitesses de fonctionnement nettement plus élevées en raison de leurs temps de commutation intrinsèquement plus courts par rapport aux tubes à vide ou aux relais. Les améliorations combinées de la fiabilité et la vitesse considérablement accrue de ces éléments de commutation, qui à cette époque étaient presque exclusivement des transistors, ont permis des fréquences d'horloge du processeur de l'ordre des dizaines de mégahertz. Parallèlement, parallèlement à l'adoption généralisée des processeurs à transistors discrets et à circuits intégrés (CI), de nouvelles architectures hautes performances, telles que les processeurs vectoriels à instruction unique et données multiples (SIMD), ont commencé à émerger. Ces premières conceptions expérimentales ont ensuite ouvert la voie au développement de superordinateurs spécialisés, illustrés par ceux fabriqués par Cray Inc et Fujitsu Ltd.
Unités centrales de traitement d'intégration à petite échelle
Cette époque a vu le développement d'une méthode permettant de fabriquer de nombreux transistors interconnectés dans un format compact. Le circuit intégré (CI) a facilité la fabrication d'une quantité substantielle de transistors sur une seule puce semi-conductrice, communément appelée « puce ». Initialement, seuls les circuits numériques fondamentaux non spécialisés, tels que les portes NOR, étaient miniaturisés en circuits intégrés. Les unités centrales de traitement (CPU) construites à partir de ces circuits intégrés « de base » sont généralement classées dans la catégorie des dispositifs « d'intégration à petite échelle » (SSI). Les circuits intégrés SSI, illustrés par ceux utilisés dans l'ordinateur de guidage Apollo, incorporaient généralement jusqu'à plusieurs dizaines de transistors. La construction d'un processeur complet à partir de circuits intégrés SSI nécessitait des milliers de puces individuelles, mais cette approche réduisait considérablement l'espace et la consommation d'énergie par rapport aux architectures à transistors discrets précédentes.
Le System/370 d'IBM, succédant au System/360, a adopté les circuits intégrés SSI au lieu des modules à transistors discrets de Solid Logic Technology. De même, les PDP-8/I et KI10 PDP-10 de DEC sont passés des transistors individuels utilisés dans les PDP-8 et KA PDP-10 aux circuits intégrés SSI. De plus, leur série à succès PDP-11 utilisait initialement des circuits intégrés SSI, mais est ensuite passée aux composants d'intégration à grande échelle (LSI) à mesure qu'ils devenaient viables.
Intégration à grande échelle dans les processeurs
Lee Boysel est l'auteur de publications influentes, notamment un « manifeste » de 1967, détaillant la construction d'un équivalent d'ordinateur central 32 bits utilisant un nombre relativement restreint de circuits d'intégration à grande échelle (LSI). La méthode exclusive de fabrication des puces LSI, définies comme celles contenant une centaine de portes ou plus, impliquait l'utilisation d'un processus de fabrication de semi-conducteurs métal-oxyde-semi-conducteur (MOS), englobant la logique PMOS, NMOS ou CMOS. Néanmoins, certains fabricants ont persisté à développer des processeurs utilisant des puces bipolaires à transistor-transistor logique (TTL), car les transistors à jonction bipolaire offraient une vitesse supérieure à celle des puces MOS jusque dans les années 1970 ; quelques entités, comme Datapoint, ont poursuivi cette pratique jusqu'au début des années 1980. Au cours des années 1960, les circuits intégrés MOS affichaient des performances plus lentes et étaient initialement jugés adaptés principalement aux applications à faible consommation. Suite au développement par Federico Faggin de la technologie MOS à grille de silicium chez Fairchild Semiconductor en 1968, les circuits intégrés MOS ont principalement remplacé le TTL bipolaire en tant que technologie de puce dominante à la fin des années 1970.
Avec la progression de la technologie microélectronique, un nombre croissant de transistors ont été intégrés sur les circuits intégrés, réduisant ainsi la quantité de circuits intégrés discrets nécessaires pour un processeur complet. L'intégration à moyenne échelle (MSI) et les circuits intégrés LSI ont augmenté le nombre de transistors, initialement à des centaines, puis à des milliers. En 1968, le nombre de circuits intégrés requis pour construire un processeur complet était tombé à 24, comprenant huit types distincts, chaque circuit intégré intégrant environ 1 000 MOSFET. Contrastant considérablement avec ses antécédents SSI et MSI, la première itération LSI du PDP-11 comportait un processeur construit à partir de seulement quatre circuits intégrés LSI.
Microprocesseurs
Depuis leur introduction initiale, les microprocesseurs ont largement supplanté toutes les autres méthodologies de mise en œuvre d'unités centrales de traitement. Le premier microprocesseur disponible dans le commerce, introduit en 1971, était l'Intel 4004. L'Intel 4004 représentait l'un des processeurs pionniers destinés au grand public à intégrer l'unité logique arithmétique, l'unité de contrôle et l'unité de registre sur une seule puce. Le premier microprocesseur largement adopté, sorti en 1974, était l'Intel 8080. Parallèlement, les fabricants d'ordinateurs centraux et de mini-ordinateurs ont lancé des programmes propriétaires de développement de circuits intégrés pour moderniser leurs architectures informatiques existantes, produisant finalement des microprocesseurs compatibles avec les jeux d'instructions qui maintenaient une compatibilité ascendante avec leur matériel et leurs logiciels existants. Parallèlement à l'émergence et à l'adoption généralisée de l'ordinateur personnel, la désignation CPU est désormais principalement réservée aux microprocesseurs. Plusieurs processeurs, appelés cœurs, peuvent être intégrés dans une seule puce de traitement.
Les anciennes unités centrales (CPU) étaient construites à partir de composants discrets et de plusieurs petits circuits intégrés (CI) répartis sur une ou plusieurs cartes de circuits imprimés. En revanche, les microprocesseurs représentent des processeurs fabriqués sur un nombre minimal de circuits intégrés, généralement un seul. Cette réduction de l'encombrement du processeur, obtenue grâce à la mise en œuvre d'une seule puce, facilite des temps de commutation accélérés en raison d'attributs physiques tels qu'une diminution de la capacité parasite de la grille. Par conséquent, les microprocesseurs synchrones ont atteint des fréquences d’horloge allant de plusieurs dizaines de mégahertz à plusieurs gigahertz. De plus, la capacité de fabriquer des transistors exceptionnellement petits sur un circuit intégré a augmenté de façon exponentielle la complexité et le nombre de transistors au sein d'un seul processeur. Cette tendance omniprésente est résumée par la loi de Moore, qui prévoyait avec précision la complexité croissante des processeurs et autres circuits intégrés jusqu'en 2016 environ.
Malgré des transformations significatives dans la complexité, les dimensions physiques, les méthodologies de construction et l'architecture globale des processeurs depuis 1950, leur conception fondamentale et leurs principes opérationnels sont restés largement cohérents. La grande majorité des processeurs contemporains sont précisément caractérisés comme des architectures à programme stocké de von Neumann. Avec la disparition de la précision prédictive de la loi de Moore, des appréhensions sont apparues concernant les limites inhérentes à la technologie des transistors à circuits intégrés. La miniaturisation profonde des portes électroniques exacerbe l’impact de phénomènes tels que l’électromigration et les fuites inférieures au seuil. Ces défis émergents font partie des nombreux facteurs qui incitent les chercheurs à explorer de nouveaux paradigmes informatiques, notamment l'informatique quantique, et à élargir l'application du parallélisme et d'autres stratégies qui améliorent l'utilité du modèle classique de von Neumann.
Principes opérationnels
Indépendamment de leur manifestation physique, la fonction principale de la plupart des unités centrales de traitement (CPU) consiste à exécuter une séquence prédéterminée d'instructions stockées, collectivement appelées programme. Ces instructions résident dans une forme de mémoire informatique. Pratiquement tous les processeurs adhèrent à une séquence opérationnelle en trois étapes : récupérer, décoder et exécuter, qui constituent ensemble le cycle d'instruction.
Après l'exécution de l'instruction, le processus se réitère, le cycle d'instruction qui s'ensuit récupérant généralement l'instruction séquentielle suivante en raison de la valeur incrémentée dans le compteur du programme. Si une instruction de saut est exécutée, le compteur de programme est reconfiguré pour contenir l'adresse de l'instruction cible, permettant ainsi à l'exécution du programme de se dérouler comme d'habitude. Les processeurs avancés sont capables de récupérer, décoder et exécuter simultanément plusieurs instructions. Cette discussion décrit le « pipeline RISC classique », une architecture répandue dans les processeurs plus simples fréquemment utilisés dans de nombreux appareils électroniques, souvent désignés comme microcontrôleurs. Il omet délibérément la fonction critique du cache CPU et, par conséquent, l'étape d'accès au pipeline.
Certaines instructions modifient directement le compteur du programme au lieu de générer des données de sortie ; ceux-ci sont communément appelés « sauts » et permettent des constructions de programmation telles que des boucles, une exécution conditionnelle (via des sauts conditionnels) et des appels de fonction. Au sein de processeurs spécifiques, d'autres instructions modifient les états des bits dans un registre « drapeaux ». Ces indicateurs servent à moduler le comportement du programme en signalant les résultats de diverses opérations. Par exemple, dans ces processeurs, une instruction « comparer » évalue deux valeurs et définit ou efface ensuite des bits dans le registre des drapeaux pour indiquer leur ampleur relative ou leur égalité ; l'un de ces indicateurs peut ensuite être utilisé par une instruction de saut ultérieure pour dicter le déroulement du programme.
Récupération d'instructions
L'étape de récupération consiste à récupérer une instruction, généralement représentée sous la forme d'une valeur numérique ou d'une séquence, à partir de la mémoire du programme. L'adresse mémoire de l'instruction est spécifiée par le compteur de programme (PC), appelé « pointeur d'instruction » dans les microprocesseurs Intel x86, qui contient l'adresse de l'instruction suivante en attente de récupération. Après la récupération de l'instruction, le PC est incrémenté de la longueur de l'instruction pour pointer vers l'adresse de l'instruction suivante dans la séquence d'exécution. Souvent, la récupération d'instructions à partir d'une mémoire relativement lente peut provoquer des blocages du processeur en attendant la récupération des données. Ce défi est principalement atténué dans les processeurs contemporains grâce à la mise en œuvre de caches et d'architectures de pipeline.
Décodage des instructions
Les actions du processeur sont dictées par les instructions extraites de la mémoire. Pendant la phase de décodage, des circuits de décodeur binaire spécialisés, appelés décodeur d'instructions, traduisent cette instruction en signaux de contrôle qui régissent les opérations des autres composants du processeur.
L'interprétation d'une instruction est régie par l'architecture du jeu d'instructions (ISA) du processeur. Généralement, un groupe de bits spécifique, ou « champ », au sein de l'instruction, appelé opcode, désigne l'opération à exécuter. Parallèlement, d'autres champs fournissent généralement des données supplémentaires nécessaires à l'opération, comme des opérandes. Ces opérandes peuvent être définis soit comme une constante (une valeur immédiate), soit comme un emplacement, qui peut être un registre de processeur ou une adresse mémoire, selon le mode d'adressage spécifié.
Certaines architectures de processeur intègrent un circuit de décodeur binaire câblé et immuable pour le décodage des instructions. À l'inverse, d'autres conceptions utilisent un microprogramme pour traduire les instructions en séquences de signaux de configuration du processeur, qui sont appliquées sur des impulsions d'horloge successives. Dans des cas spécifiques, la mémoire hébergeant le microprogramme est réinscriptible, permettant ainsi de modifier la méthodologie de décodage des instructions du CPU.
Phase d'exécution
Après les étapes de récupération et de décodage, la phase d'exécution commence. Cette phase peut comprendre soit une action unique, soit une série d'actions, en fonction de la conception architecturale du processeur. Pour chaque action, des signaux de commande activent ou désactivent électroniquement des composants spécifiques du processeur, leur permettant d'effectuer la totalité ou une partie de l'opération prévue. L'action se termine généralement à la réception d'une impulsion d'horloge. Souvent, les résultats sont stockés dans un registre interne du processeur pour faciliter une récupération rapide par des instructions ultérieures. Alternativement, les résultats peuvent être stockés dans la mémoire principale, qui offre un accès plus lent mais est plus économique et possède une plus grande capacité.
Par exemple, lorsqu'une instruction d'addition est exécutée, les registres contenant les opérandes (les nombres à additionner) sont activés, aux côtés des sections pertinentes de l'unité logique arithmétique (ALU) responsable de l'addition. Lors de l'apparition d'une impulsion d'horloge, les opérandes sont transférés de leurs registres sources vers l'ALU et la somme résultante est générée à sa sortie. Les impulsions d'horloge ultérieures facilitent l'activation et la désactivation d'autres composants pour transférer la sortie (la somme de l'opération) vers un emplacement de stockage désigné, tel qu'un registre ou une mémoire. Si la somme calculée dépasse la taille du mot de sortie de l'ALU, un indicateur de dépassement arithmétique est défini, ce qui a ensuite un impact sur l'opération suivante.
Conception architecturale et mise en œuvre
Les opérations fondamentales qu'un processeur peut exécuter sont intrinsèquement intégrées dans ses circuits, formant collectivement un jeu d'instructions. Ces opérations englobent des tâches telles que l'addition ou la soustraction arithmétique, les comparaisons numériques ou le contrôle du déroulement du programme (par exemple, passer à un segment de code différent). Chaque instruction est codée de manière unique par un modèle de bits spécifique, appelé opcode du langage machine. Pendant le traitement des instructions, le CPU utilise un décodeur binaire pour traduire l'opcode en signaux de contrôle, qui coordonnent ensuite les fonctions internes du CPU. Une instruction complète en langage machine comprend généralement un opcode ainsi que des bits supplémentaires qui définissent les arguments de l'opération (par exemple, les valeurs à ajouter dans une instruction d'addition). À un niveau d'abstraction supérieur, un programme en langage machine constitue une séquence ordonnée d'instructions en langage machine exécutées par le processeur.
Les opérations mathématiques de base de chaque instruction sont exécutées par un circuit logique combinatoire situé dans le processeur du processeur, connu sous le nom d'unité arithmétique-logique (ALU). En règle générale, un processeur traite une instruction en la récupérant de la mémoire, en utilisant son ALU pour effectuer l'opération spécifiée, puis en remettant le résultat en mémoire. Au-delà des instructions pour les opérations arithmétiques et logiques sur les nombres entiers, il existe un large éventail d'autres instructions machine, y compris celles pour le transfert de données (chargement et stockage vers la mémoire), le branchement conditionnel et l'arithmétique à virgule flottante, qui sont gérées par l'unité à virgule flottante (FPU) du processeur.
L'unité de contrôle
L'unité de contrôle (CU) est un composant intégré du processeur chargé d'orchestrer les opérations du processeur. Il émet des directives à la mémoire de l'ordinateur, à l'unité arithmétique et logique et aux périphériques d'entrée/sortie, leur indiquant comment répondre aux commandes transmises au processeur.
L'unité de contrôle (CU) orchestre les opérations d'autres composants en générant des signaux de synchronisation et de contrôle. Il gère la majorité des ressources informatiques et dirige le flux de données entre l'unité centrale (CPU) et les périphériques. John von Neumann a incorporé l'unité de contrôle comme élément fondamental de l'architecture von Neumann. Dans les conceptions informatiques contemporaines, l'unité de contrôle est généralement intégrée au processeur, conservant sa fonction essentielle et ses principes de fonctionnement depuis sa création.
Unité arithmétique et logique
L'unité arithmétique et logique (ALU) constitue un circuit numérique intégré au processeur, chargé d'exécuter des opérations arithmétiques sur les nombres entiers et logiques au niveau des bits. Les entrées de l'ALU comprennent les mots de données désignés pour le traitement (appelés opérandes), les données d'état des opérations précédentes et un code opérationnel fourni par l'unité de commande. L'origine de ces opérandes varie en fonction de l'instruction en cours d'exécution, provenant potentiellement des registres internes du processeur, de la mémoire externe ou des constantes générées en interne par l'ALU.
Lors de la stabilisation et de la propagation de tous les signaux d'entrée à travers les circuits de l'ALU, le résultat de l'opération exécutée devient disponible aux sorties de l'ALU. Ce résultat englobe à la fois un mot de données, qui peut ensuite être stocké dans un registre ou une mémoire, et des informations d'état, généralement conservées dans un registre CPU interne dédié.
Les unités centrales de traitement (CPU) contemporaines intègrent fréquemment plusieurs unités logiques arithmétiques (ALU) pour améliorer les performances de calcul.
Unité de génération d'adresse
L'unité de génération d'adresses (AGU), également connue sous le nom d'unité de calcul d'adresses (ACU), est un composant d'exécution au sein de l'unité centrale (CPU) responsable du calcul des adresses mémoire requises pour accéder à la mémoire principale. La délégation des calculs d'adresses à des circuits dédiés qui fonctionnent simultanément avec d'autres fonctions du processeur réduit le nombre de cycles du processeur nécessaires à l'exécution des instructions machine, améliorant ainsi les performances.
Au cours de divers processus opérationnels, les processeurs doivent calculer les adresses mémoire pour récupérer les données de la mémoire ; par exemple, les emplacements en mémoire des éléments du tableau nécessitent un calcul avant la récupération des données à partir de leurs adresses de mémoire physique. Ces calculs de génération d'adresses impliquent diverses opérations arithmétiques sur les nombres entiers, notamment l'addition, la soustraction, les opérations modulo et les décalages de bits. Souvent, la détermination d’une adresse mémoire nécessite plusieurs instructions machine à usage général, qui peuvent ne pas être décodées et exécutées efficacement. L'intégration d'un AGU dans une architecture de processeur, ainsi que d'instructions spécialisées exploitant l'AGU, permet de décharger de nombreux calculs de génération d'adresses du processeur principal, facilitant souvent leur exécution rapide au sein d'un seul cycle de processeur.
Les fonctionnalités d'un AGU dépendent du processeur spécifique et de sa conception architecturale. Par conséquent, certaines AGU mettent en œuvre et exposent une gamme plus large d'opérations de calcul d'adresse, tandis que d'autres intègrent des instructions spécialisées plus sophistiquées capables de traiter plusieurs opérandes simultanément. Certaines architectures de processeur comportent plusieurs AGU, permettant l'exécution simultanée de plusieurs opérations de calcul d'adresse, générant ainsi des gains de performances supplémentaires attribués aux caractéristiques superscalaires des conceptions de processeur avancées. Par exemple, Intel intègre plusieurs AGU dans ses microarchitectures Sandy Bridge et Haswell, améliorant ainsi la bande passante du sous-système de mémoire du processeur en facilitant l'exécution parallèle de plusieurs instructions d'accès à la mémoire.
Unité de gestion de mémoire (MMU)
De nombreux microprocesseurs, présents dans des appareils tels que les smartphones, les ordinateurs de bureau, les ordinateurs portables et les serveurs, intègrent une unité de gestion de mémoire (MMU). Cette unité traduit les adresses logiques en adresses RAM physiques, offrant simultanément une protection de la mémoire et des capacités de pagination essentielles à la mise en œuvre de la mémoire virtuelle. Bien qu'elle soit généralement intégrée au processeur, la MMU peut parfois résider dans un circuit intégré (IC) séparé. Les processeurs plus simples, en particulier les microcontrôleurs, n'incluent généralement pas de MMU.
Cache
Un cache CPU est une mémoire utilisée par l'unité centrale de traitement (CPU) d'un ordinateur pour minimiser la latence moyenne et la consommation d'énergie associées à l'accès aux données de la mémoire principale. Un cache est une mémoire compacte à haute vitesse située à proximité d'un cœur de processeur, qui conserve les doublons des données fréquemment consultées résidant dans la mémoire principale. La plupart des processeurs intègrent plusieurs caches distincts, généralement structurés hiérarchiquement en plusieurs niveaux (L1, L2, L3, L4, etc.). Les niveaux de cache successifs dans cette hiérarchie se caractérisent généralement par une capacité accrue mais une vitesse réduite par rapport à leurs prédécesseurs, L1 représentant le niveau le plus rapide et le plus proche du processeur. Le niveau L1 intègre généralement des caches séparés pour les instructions et les données.
Les unités centrales de traitement (CPU) hautes performances contemporaines, à de rares exceptions près, intègrent plusieurs niveaux hiérarchiques de mémoire cache. Les implémentations initiales de processeur comportant de la mémoire cache utilisaient un seul niveau de cache qui, contrairement aux caches L1 ultérieurs, n'était pas divisé en composants distincts L1d (données) et L1i (instruction). Pratiquement tous les processeurs actuels équipés de caches utilisent une architecture de cache L1 divisée. Ces processeurs incluent également généralement des caches L2, les processeurs plus grands intégrant également des caches L3. Le cache L2 est généralement unifié (non divisé) et fonctionne comme un référentiel partagé pour les données du cache L1 divisé. Au sein d'un processeur multicœur, chaque cœur possède un cache L2 dédié, qui n'est généralement pas partagé entre les autres cœurs. À l’inverse, les caches L3 et tous les caches ultérieurs de niveau supérieur sont partagés sur plusieurs cœurs et restent non divisés. Le cache L4 est actuellement peu courant et est généralement implémenté à l'aide d'une mémoire vive dynamique (DRAM) plutôt que d'une mémoire vive statique (SRAM), résidant souvent sur une puce ou une puce distincte. Historiquement, un placement externe similaire s'appliquait aux caches L1 ; cependant, les progrès dans la fabrication des puces ont permis l'intégration de L1 et de la plupart des autres niveaux de cache sur la puce du processeur principal, à l'exception potentielle du cache de plus haut niveau. Chaque niveau de cache supplémentaire est généralement caractérisé par une capacité accrue et des stratégies d'optimisation distinctes.
Au-delà de la hiérarchie du cache principal, il existe d'autres types de cache spécialisés, qui ne sont généralement pas inclus dans la métrique globale de « taille du cache » des caches principaux susmentionnés. Un exemple est le tampon de traduction (TLB), un composant intégral de l'unité de gestion de la mémoire (MMU) que l'on trouve dans la plupart des processeurs.
Les capacités de cache sont généralement dimensionnées en puissances de deux, par exemple 2, 8 ou 16 Ko, ou en MiB pour les caches non L1 plus grands. Cependant, des exceptions existent, illustrées par l'IBM z13, qui dispose d'un cache d'instructions L1 de 96 Ko.
Taux d'horloge
La majorité des unités centrales de traitement fonctionnent comme des circuits synchrones, utilisant un signal d'horloge pour réguler leurs opérations séquentielles. Ce signal d'horloge provient d'un circuit oscillateur externe, qui produit un nombre constant d'impulsions par seconde, se manifestant par une onde carrée périodique. La fréquence de ces impulsions d'horloge dicte la fréquence d'exécution des instructions du CPU ; par conséquent, une fréquence d'horloge plus élevée permet au processeur de traiter un plus grand nombre d'instructions par seconde.
Pour que le processeur fonctionne correctement, la période d'horloge doit dépasser la durée maximale requise pour que tous les signaux internes se propagent dans toute l'unité. En établissant une période d'horloge nettement supérieure au délai de propagation le plus défavorable, les concepteurs peuvent synchroniser l'ensemble du fonctionnement du processeur et le mouvement des données avec les fronts montants et descendants du signal d'horloge. Cette approche offre l'avantage substantiel de simplifier la conception du processeur et de réduire la complexité des composants. Néanmoins, un inconvénient est que l'ensemble du processeur est limité par ses composants les plus lents, même lorsque d'autres sections fonctionnent à des vitesses considérablement plus élevées. Cette limitation inhérente a été largement atténuée grâce à la mise en œuvre de diverses techniques visant à améliorer le parallélisme du processeur.
Néanmoins, les progrès architecturaux ne suffisent pas à résoudre entièrement tous les inconvénients inhérents aux processeurs globalement synchrones. Par exemple, un signal d’horloge, comme tout autre signal électrique, est sensible aux retards de propagation. Des fréquences d'horloge élevées dans des processeurs de plus en plus complexes exacerbent le défi du maintien de la synchronisation de phase du signal d'horloge sur l'ensemble de l'unité de traitement. Par conséquent, de nombreux processeurs contemporains nécessitent la fourniture de plusieurs signaux d'horloge identiques pour éviter des retards importants dans un seul signal qui pourraient entraîner un dysfonctionnement du processeur. Une autre préoccupation importante, en particulier avec des augmentations substantielles des fréquences d'horloge, est la dissipation thermique croissante générée par le processeur. Le basculement continu du signal d'horloge oblige de nombreux composants à changer d'état, quelle que soit leur utilisation active. En général, un composant de commutation consomme plus d'énergie qu'un composant statique. Ainsi, une augmentation de la fréquence d'horloge est directement corrélée à une consommation d'énergie plus élevée, nécessitant ainsi des mécanismes de dissipation thermique plus robustes, souvent sous la forme de solutions spécialisées de refroidissement du processeur.
Une technique pour gérer l'activation des composants superflus est le clock gating, qui consiste à désactiver le signal d'horloge fourni à ces composants, les rendant ainsi inopérants. Néanmoins, sa mise en œuvre est souvent considérée comme difficile, limitant son adoption généralisée à des conceptions spécialisées de faible consommation. Un exemple frappant d'application étendue de gestion d'horloge est le processeur Xenon basé sur IBM PowerPC dans la Xbox 360, qui contribue de manière significative à réduire la consommation électrique de la console.
CPU sans horloge
Une approche alternative pour atténuer les problèmes associés à un signal d'horloge global implique son élimination complète. Bien que l'absence d'un signal d'horloge global augmente considérablement la complexité de conception, les architectures asynchrones (ou sans horloge) offrent des avantages distincts en termes de consommation d'énergie et de gestion thermique par rapport à leurs homologues synchrones. Malgré leur relative rareté, des unités centrales asynchrones complètes ont été développées sans s'appuyer sur un signal d'horloge global. Des exemples illustratifs incluent AMULET compatible ARM et MiniMIPS compatible MIPS R3000.
Au lieu d'éliminer complètement le signal d'horloge, certaines architectures de processeur intègrent des éléments asynchrones dans des sections de périphérique spécifiques. Par exemple, l’intégration d’unités arithmétiques et logiques (ALU) asynchrones avec un pipeline superscalaire peut améliorer les performances arithmétiques. Bien que la parité ou la supériorité globale des performances des conceptions entièrement asynchrones par rapport aux conceptions synchrones reste un domaine d'investigation en cours, elles démontrent clairement une maîtrise des calculs mathématiques moins complexes. Cette caractéristique, associée à leur efficacité énergétique et à leur dissipation thermique supérieures, les rend parfaitement adaptés aux applications informatiques embarquées.
Module régulateur de tension
Les unités centrales de traitement contemporaines intègrent fréquemment un module de gestion de l'alimentation intégré à la puce. Ce module régule dynamiquement l'alimentation en tension des circuits du processeur, optimisant ainsi l'équilibre entre les performances opérationnelles et la consommation d'énergie.
Plage d'entiers
Chaque unité centrale de traitement utilise une méthodologie distincte pour représenter les valeurs numériques. Historiquement, certains premiers systèmes informatiques numériques utilisaient des valeurs de système numérique décimal (base 10) familières, tandis que d'autres adoptaient des représentations moins conventionnelles, notamment des valeurs décimales codées bi-quinaires (base 2 à 5) ou ternaires (base 3). Actuellement, la grande majorité des processeurs modernes représentent des nombres au format binaire, où chaque chiffre correspond à un état physique à deux valeurs, comme une tension « haute » ou « basse ».
La taille et la précision des nombres entiers représentables par un processeur sont intrinsèquement liées à son schéma de représentation numérique. Pour un processeur binaire, cette caractéristique est quantifiée par le nombre de bits (qui sont les chiffres significatifs d'un entier codé en binaire) que le processeur peut traiter en une seule opération. Cette métrique est fréquemment appelée taille des mots, largeur en bits, largeur du chemin de données, précision entière ou taille entière. La taille entière d'un processeur dicte le spectre de valeurs entières sur lesquelles il peut directement effectuer des opérations. Par exemple, un processeur 8 bits est capable de manipuler directement des entiers représentés par huit bits, englobant une plage de 256 (2§1011§) valeurs entières distinctes.
La plage entière influence également la quantité d'emplacements mémoire qu'un processeur peut adresser directement, où une adresse constitue une valeur entière désignant un emplacement mémoire particulier. Par exemple, si un processeur binaire utilise 32 bits pour représenter une adresse mémoire, il peut accéder directement à 232 emplacements mémoire distincts. Pour surmonter cette limitation inhérente, entre autres considérations, certains processeurs mettent en œuvre des mécanismes tels que la gestion de la mémoire ou la commutation de banque, qui facilitent l'adressage des capacités de mémoire étendues.
Les processeurs dotés de mots de plus grande taille nécessitent davantage de circuits, ce qui entraîne des dimensions physiques plus importantes, des coûts de fabrication plus élevés et une consommation d'énergie plus élevée, ce qui génère davantage de chaleur. Par conséquent, malgré la disponibilité de processeurs avec des tailles de mots nettement plus grandes (par exemple 16, 32, 64 ou même 128 bits), des microcontrôleurs compacts de 4 ou 8 bits sont fréquemment déployés dans les applications contemporaines. Néanmoins, dans les scénarios exigeant des performances supérieures, les avantages d’une taille de mot étendue, tels que des plages de données plus larges et des espaces d’adressage plus grands, peuvent supplanter ces inconvénients. Pour réduire la taille et le coût, un processeur peut incorporer des chemins de données internes plus étroits que la taille nominale des mots. Par exemple, bien que l'architecture du jeu d'instructions IBM System/360 soit de 32 bits, les System/360 Model 30 et Model 40 présentaient des chemins de données de 8 bits dans leurs unités logiques arithmétiques, nécessitant quatre cycles pour une addition de 32 bits, chaque cycle traitant 8 bits des opérandes. De même, bien que le jeu d'instructions de la série Motorola 68000 soit de 32 bits, les Motorola 68000 et Motorola 68010 utilisaient des chemins de données de 16 bits dans leurs unités logiques arithmétiques, nécessitant ainsi deux cycles pour une addition de 32 bits.
Pour tirer parti des avantages associés aux longueurs de bits plus courtes et plus longues, de nombreux jeux d'instructions utilisent des largeurs de bits distinctes pour les données entières et à virgule flottante. Cette approche de conception permet aux processeurs implémentant de tels jeux d'instructions de présenter différentes largeurs de bits sur différents composants internes. Par exemple, le jeu d'instructions IBM System/360, bien que principalement 32 bits, incorporait la prise en charge des valeurs à virgule flottante 64 bits pour améliorer la précision et la portée des calculs numériques. Plus précisément, le System/360 Model 65 comprenait un additionneur de 8 bits pour les opérations binaires décimales et à virgule fixe, ainsi qu'un additionneur de 60 bits dédié à l'arithmétique à virgule flottante. Les architectures de processeur ultérieures adoptent fréquemment des stratégies similaires de largeur de bit mixte, en particulier dans les processeurs à usage général où un équilibre optimal entre les capacités de traitement des nombres entiers et des virgules flottantes est essentiel.
Parallélisme
La section précédente détaillait les principes de fonctionnement fondamentaux d'un processeur, illustrant sa configuration la plus rudimentaire. Cette architecture de processeur, communément appelée sous-scalaire, traite et exécute simultanément une seule instruction sur un ou deux éléments de données, ce qui entraîne une mesure de performances inférieure à une instruction par cycle d'horloge (IPC < 1).
Ce paradigme opérationnel introduit intrinsèquement des inefficacités au sein des processeurs sous-scalaires. Étant donné qu'une seule instruction est exécutée à un moment donné, l'ensemble du processeur doit faire une pause jusqu'à la fin de l'instruction en cours avant de lancer la suivante. Par conséquent, les processeurs sous-scalaires subissent des retards lorsqu’ils rencontrent des instructions qui nécessitent plusieurs cycles d’horloge pour leur exécution. Même l’intégration d’une unité d’exécution supplémentaire n’améliore pas sensiblement les performances ; au lieu d'une seule voie bloquée, deux voies se bloquent, entraînant une augmentation du nombre de transistors inutilisés. Cette conception architecturale, où les ressources d'exécution du processeur sont limitées au traitement d'une instruction à la fois, peut théoriquement atteindre un maximum de performances scalaires, définies comme une instruction par cycle d'horloge (IPC = 1). Cependant, les performances réelles restent généralement sous-scalaires, indiquant moins d'une instruction par cycle d'horloge (IPC < 1).
Les efforts visant à atteindre des performances scalaires ou supérieures ont conduit au développement de diverses méthodologies de conception qui favorisent un fonctionnement du processeur moins linéaire et plus parallèle. Dans le contexte du parallélisme des processeurs, deux termes principaux sont couramment utilisés pour catégoriser ces techniques de conception :
Le- Parallélisme au niveau des instructions (ILP) vise à accélérer le taux d'exécution des instructions au sein d'un processeur, maximisant ainsi l'utilisation des ressources d'exécution sur puce. Le
- Parallélisme au niveau des tâches (TLP) est conçu pour augmenter la quantité de threads ou de processus qu'un processeur peut exécuter simultanément.
Chaque méthodologie présente des approches de mise en œuvre distinctes et offre différents degrés d'efficacité pour améliorer les performances du processeur pour des applications spécifiques.
Parallélisme au niveau de l'instruction
Une approche fondamentale pour améliorer le parallélisme informatique consiste à lancer les phases initiales de récupération et de décodage des instructions avant la fin de l'exécution de l'instruction précédente. Cette méthodologie, appelée pipeline d'instructions, est omniprésente dans presque toutes les unités centrales de traitement (CPU) à usage général contemporaines. Le pipeline facilite l'exécution simultanée de plusieurs instructions en segmentant le chemin d'exécution en étapes distinctes et séquentielles. Cette décomposition architecturale est analogue à une chaîne d'assemblage, où chaque instruction progresse à travers des étapes successives, devenant progressivement plus complète jusqu'à ce qu'elle quitte le pipeline d'exécution et soit retirée.
Cependant, le pipeline introduit intrinsèquement un potentiel de conflits de dépendances de données, un scénario dans lequel le résultat d'une opération précédente est requis pour l'achèvement d'une opération ultérieure. Par conséquent, les processeurs pipeline sont conçus pour détecter de telles conditions et, si nécessaire, introduire des retards dans des segments spécifiques du pipeline. Un processeur pipeline peut atteindre des niveaux de performances proches de ceux d'un processeur scalaire, son efficacité étant principalement limitée par les blocages du pipeline, qui se produisent lorsqu'une instruction occupe une étape pendant plus d'un cycle d'horloge.
Les progrès en matière de pipeline d'instructions ont progressivement réduit les périodes d'inactivité des composants du processeur. Les architectures superscalaires se caractérisent par des pipelines d'instructions étendus et l'intégration de plusieurs unités d'exécution identiques, englobant des composants tels que des unités de chargement-stockage, des unités arithmétiques-logiques, des unités à virgule flottante et des unités de génération d'adresses. Au sein d'un pipeline superscalaire, les instructions sont récupérées et transmises à un répartiteur, qui détermine leur potentiel d'exécution parallèle (simultanée). Si une exécution parallèle est réalisable, les instructions sont ensuite envoyées aux unités d'exécution appropriées, conduisant à leur traitement simultané. Fondamentalement, le débit d'un processeur superscalaire, mesuré par le nombre d'instructions terminées par cycle, est directement corrélé à sa capacité à envoyer simultanément des instructions à ces unités d'exécution.
Un défi important dans la conception d'architectures de processeur superscalaires réside dans le développement d'un répartiteur efficace. Ce composant doit vérifier rapidement l'exécutabilité parallèle des instructions et ensuite les distribuer pour maximiser l'utilisation des unités d'exécution disponibles. Pour y parvenir, il faut un réapprovisionnement fréquent du pipeline d'instructions et des ressources de cache CPU substantielles. De plus, les stratégies d’évitement des risques, notamment la prédiction de branchement, l’exécution spéculative, le renommage des registres, l’exécution dans le désordre et la mémoire transactionnelle, deviennent indispensables pour maintenir des niveaux de performances élevés. Grâce à la prédiction du chemin de branchement probable pour les instructions conditionnelles, le processeur peut réduire considérablement les cas où l'ensemble du pipeline doit stagner en attendant la fin d'une opération conditionnelle. L'exécution spéculative génère généralement des gains de performances modérés en exécutant des segments de code qui pourraient finalement s'avérer inutiles après une opération conditionnelle. L'exécution dans le désordre réorganise dynamiquement l'exécution des instructions pour atténuer les retards résultant des dépendances des données. De plus, dans les scénarios impliquant un seul flux d'instructions fonctionnant sur plusieurs flux de données, en particulier lors du traitement de grands volumes de données homogènes, les processeurs modernes peuvent désactiver de manière sélective des segments de pipeline. Cela permet au processeur de contourner les phases de récupération et de décodage lorsqu'une seule instruction est exécutée de manière répétée, améliorant ainsi considérablement les performances dans des contextes spécifiques, notamment au sein de moteurs de calcul très répétitifs tels que les logiciels de création vidéo et de traitement de photos.
Lorsque seul un sous-ensemble des composants d'un processeur présente des capacités superscalaires, les parties non superscalaires subissent une surcharge de performances attribuée aux blocages de planification. Par exemple, le Pentium Intel P5 comportait deux unités logiques arithmétiques (ALU) superscalaires, chacune capable d'accepter une instruction par cycle d'horloge, mais son unité à virgule flottante (FPU) n'avait pas cette capacité. Par conséquent, le P5 a été caractérisé comme étant un superscalaire entier mais pas un superscalaire à virgule flottante. L'architecture P6 ultérieure d'Intel a étendu la fonctionnalité superscalaire à ses opérations en virgule flottante.
Les architectures pipeline et superscalaires améliorent le parallélisme au niveau des instructions (ILP) d'un processeur en permettant l'exécution de plusieurs instructions par cycle d'horloge. Les conceptions de processeurs contemporaines intègrent fréquemment des capacités superscalaires, pratiquement tous les processeurs à usage général développés au cours de la dernière décennie présentant cette caractéristique architecturale. Par la suite, l'accent mis sur le développement de systèmes informatiques à ILP élevé s'est déplacé des implémentations matérielles du processeur vers l'interface logicielle, en particulier l'architecture du jeu d'instructions (ISA). L'approche VLIW (Very Long Instruction Word) intègre intrinsèquement un certain degré d'ILP dans le logiciel, réduisant ainsi la charge du processeur pour maximiser l'ILP et simplifier sa conception.
Parallélisme au niveau des tâches
Une approche alternative pour améliorer les performances de calcul implique l'exécution simultanée de plusieurs threads ou processus. Ce domaine d'étude est appelé calcul parallèle. Dans la taxonomie de Flynn, cette méthodologie est classée comme Instruction Multiple, Données Multiples (MIMD).
Le multitraitement (MP) représente une technologie clé utilisée pour cet objectif. La forme fondamentale de cette technologie est le multitraitement symétrique (SMP), caractérisé par un nombre limité d'unités centrales (CPU) partageant une vue de mémoire unifiée et cohérente. Cette conception architecturale intègre du matériel dédié au sein de chaque processeur pour garantir une cohérence continue de la mémoire. La prévention des états de mémoire obsolètes facilite la collaboration des processeurs sur les programmes partagés et permet la migration des programmes entre différents processeurs. Pour augmenter le nombre de processeurs coopérants au-delà d'un nombre modeste, des protocoles d'accès à la mémoire non uniforme (NUMA) et de cohérence basés sur des répertoires ont été développés dans les années 1990. Alors que les architectures SMP sont limitées à un nombre limité de processeurs, les systèmes NUMA ont été implémentés avec succès avec des milliers de processeurs. Historiquement, les systèmes multitraitements étaient construits à l'aide de processeurs distincts et de cartes de circuits imprimés distinctes pour établir une connectivité inter-processeurs. L'intégration des processeurs et de leur interconnexion sur une seule puce de silicium définit le multitraitement au niveau de la puce (CMP), la puce unique résultante étant appelée processeur multicœur.
Les progrès ultérieurs ont révélé la présence d'un parallélisme plus fin au sein des programmes individuels. Un programme unique peut englober plusieurs threads ou fonctions capables d'une exécution indépendante ou simultanée. Les premières manifestations de cette technologie impliquaient la mise en œuvre d'opérations d'entrée/sortie, telles que l'accès direct à la mémoire, en tant que threads distincts du thread de calcul principal. Une application plus large de cette technologie a émergé dans les années 1970 avec la conception de systèmes capables d’exécuter simultanément plusieurs threads de calcul. Ce paradigme technologique est appelé multi-threading (MT). La MT est généralement considérée comme plus efficace économiquement que le multitraitement, étant donné qu'elle ne nécessite la réplication que d'un ensemble limité de composants du processeur, contrairement à la duplication complète du processeur requise pour le MP. Au sein d'une architecture MT, les unités d'exécution et la hiérarchie de la mémoire, y compris les caches, sont partagées sur plusieurs threads. Un inconvénient majeur de MT est sa plus grande visibilité matérielle sur les logiciels par rapport à MP, ce qui nécessite des modifications plus importantes des logiciels de supervision, tels que les systèmes d'exploitation, pour une prise en charge efficace. Le multithreading temporel représente une forme implémentée de MT, dans laquelle un thread s'exécute jusqu'à ce qu'il rencontre un blocage, en attendant la récupération des données de la mémoire externe. Dans ce paradigme, le processeur effectue rapidement un changement de contexte vers un autre thread prêt, complétant fréquemment la transition en un seul cycle d'horloge du processeur, comme l'illustre l'UltraSPARC T1. Le multithreading simultané constitue une autre variante de MT, caractérisée par l'exécution parallèle d'instructions provenant de plusieurs threads au sein d'un seul cycle d'horloge de processeur.
Des années 1970 au début des années 2000, l'objectif principal du développement de processeurs polyvalents hautes performances était centré sur la maximisation du parallélisme au niveau des instructions (ILP) via des techniques telles que le pipeline, la mise en cache, l'exécution superscalaire et l'exécution dans le désordre. Cette trajectoire de développement a abouti à la création de processeurs importants et gourmands en énergie, illustrés par l'Intel Pentium 4. Au début des années 2000, les architectes de processeurs ont rencontré des obstacles importants pour améliorer les performances des méthodologies ILP, principalement en raison de la divergence croissante entre les fréquences de fonctionnement du processeur et de la mémoire principale, ainsi que de la dissipation croissante de la puissance du processeur attribuée à des techniques ILP de plus en plus complexes.
Par la suite, les concepteurs de processeurs ont adopté des concepts issus des secteurs informatiques commerciaux, tels que les transactions. le traitement, où les performances collectives de nombreux programmes (appelées calcul à débit) étaient plus importantes que les performances d'un thread ou d'un processus individuel.
Le changement dans les priorités de conception est démontré par l'adoption généralisée d'architectures de processeurs multicœurs, en particulier les conceptions récentes d'Intel qui imitent son architecture P6 moins superscalaire. Les processeurs contemporains de diverses familles intègrent le multitraitement au niveau des puces, illustré par les x86-64 Opteron et Athlon 64 X2, les SPARC UltraSPARC T1, IBM POWER4 et POWER5, ainsi que plusieurs processeurs de consoles de jeux vidéo tels que le PowerPC triple cœur de la Xbox 360 et le microprocesseur Cell à sept cœurs de la PlayStation 3.
Parallélisme des données
Le parallélisme des données représente un paradigme de traitement moins répandu mais de plus en plus important, s'étendant à l'ensemble de l'informatique en général. Les processeurs évoqués précédemment sont classés comme des périphériques scalaires. En revanche, les processeurs vectoriels, comme leur désignation l'indique, traitent plusieurs éléments de données au sein d'une seule instruction, à la différence des processeurs scalaires qui gèrent un élément de données par instruction. Selon la taxonomie de Flynn, ces approches de traitement de données sont globalement classées en flux d'instruction unique, flux de données multiples (SIMD) et flux d'instruction unique et flux de données uniques (SISD), respectivement. Le principal avantage des processeurs vectoriels est leur efficacité à optimiser les opérations qui nécessitent l’application d’une fonction identique (par exemple, sommation ou produit scalaire) à des ensembles de données étendus. Les applications illustratives incluent le traitement multimédia (images, vidéo et audio) et de nombreux calculs scientifiques et techniques. Alors qu'un processeur scalaire doit effectuer séquentiellement les étapes de récupération, de décodage et d'exécution pour chaque instruction et valeur de données d'un ensemble, un processeur vectoriel peut exécuter une seule opération sur un ensemble de données considérablement plus grand à l'aide d'une seule instruction. Cette efficacité est obtenue lorsqu'une application implique fréquemment l'application d'une opération uniforme à une collection importante de données.
Historiquement, les premiers processeurs vectoriels, tels que le Cray-1, étaient principalement utilisés dans la recherche scientifique et les applications cryptographiques. Néanmoins, avec la numérisation généralisée du multimédia, l’intégration des capacités SIMD dans les processeurs à usage général a pris une importance considérable. Suite à l'adoption généralisée des unités à virgule flottante dans les processeurs à usage général, les spécifications et les implémentations des unités d'exécution SIMD ont émergé pour ces processeurs au milieu des années 1990. Les spécifications SIMD initiales, notamment les extensions d'accélération multimédia (MAX) de HP et le MMX d'Intel, étaient limitées aux opérations sur des nombres entiers. Cette limitation représentait un défi considérable pour les développeurs de logiciels, car de nombreuses applications bénéficiant de SIMD impliquent principalement des calculs en virgule flottante. Par la suite, les développeurs ont affiné de manière itérative ces conceptions fondamentales, conduisant à des spécifications SIMD contemporaines, qui sont généralement intégrées dans une architecture de jeu d'instructions (ISA) spécifique. Les instances modernes les plus importantes incluent les extensions Streaming SIMD (SSE) d'Intel et l'AltiVec associé à PowerPC (également connu sous le nom de VMX).
Compteurs de performances matérielles
Les architectures contemporaines, y compris les systèmes embarqués, intègrent fréquemment des compteurs de performances matérielles (HPC). Ces compteurs facilitent la collecte de données de bas niveau au niveau des instructions, l'analyse comparative, le débogage et l'analyse des métriques d'exécution de logiciels. Le HPC peut également être utilisé pour détecter et examiner les comportements logiciels anormaux ou potentiellement malveillants, tels que les exploits impliquant une programmation orientée retour (ROP) ou une programmation orientée retour (SROP). Cette application est généralement utilisée par les équipes de sécurité logicielle pour évaluer et identifier les programmes binaires malveillants.
De nombreux fournisseurs de premier plan, notamment IBM, Intel, AMD et Arm, proposent des interfaces logicielles, généralement implémentées en C/C++, pour extraire les mesures de performances des registres du processeur. De plus, les développeurs de systèmes d'exploitation fournissent des utilitaires tels que perf (Linux) pour enregistrer, comparer ou tracer les événements du processeur lors de l'exécution du noyau et des applications.
Les compteurs matériels offrent un mécanisme à faible surcharge pour acquérir des mesures de performances détaillées relatives aux composants fondamentaux d'un processeur (par exemple, unités fonctionnelles, caches, mémoire principale), ce qui représente une supériorité notable sur les profileurs logiciels. De plus, ils évitent généralement la nécessité de modifier le code source d'un programme. Compte tenu des variations architecturales dans les conceptions matérielles, les catégories et interprétations spécifiques des compteurs matériels varient par conséquent selon les différentes architectures.
Modes privilégiés
Les unités centrales de traitement (CPU) contemporaines intègrent généralement des modes privilégiés pour faciliter le fonctionnement des systèmes d'exploitation et des technologies de virtualisation.
Dans les environnements de cloud computing, la virtualisation permet de fournir une unité centrale virtuelle (vCPU) à des utilisateurs distincts ; il est crucial de différencier un vCPU d'un serveur privé virtuel (VPS).
Dans les contextes de virtualisation, un hôte représente la contrepartie virtuelle d'une machine physique, servant de plate-forme pour le fonctionnement d'un système virtuel. Lorsque plusieurs machines physiques fonctionnent en collaboration et sont gérées de manière cohérente, leurs ressources informatiques et mémoire combinées constituent un cluster. Certains systèmes permettent l'ajout et la suppression dynamiques de composants d'un cluster. Les ressources accessibles aux niveaux de l'hôte et du cluster peuvent être subdivisées en pools de ressources finement granulaires.
Performances
Les performances ou vitesse d'un processeur dépendent de nombreuses variables, notamment sa fréquence d'horloge (généralement exprimée en multiples de hertz) et les instructions par horloge (IPC), qui déterminent collectivement les instructions par seconde (IPS) qu'un processeur peut exécuter. De nombreux chiffres IPS publiés reflètent des taux d'exécution « maximaux » dérivés de séquences d'instructions synthétiques avec un branchement minimal. En revanche, les charges de travail authentiques comprennent diverses instructions et applications, certaines nécessitant plus de temps d'exécution que d'autres. De plus, l’efficacité de la hiérarchie mémoire influence considérablement les performances du processeur, un facteur souvent sous-estimé dans les calculs IPS. Par conséquent, pour évaluer avec précision les performances efficaces dans des applications typiques, diverses évaluations standardisées, communément appelées « benchmarks » (par exemple, SPECint), ont été conçues.
Les performances de traitement informatique sont augmentées grâce au déploiement de processeurs multicœurs, qui intègrent fondamentalement deux ou plusieurs unités de traitement discrètes (appelées cœurs) sur un seul circuit intégré. Théoriquement, un processeur double cœur devrait présenter près du double de la puissance d’une unité monocœur. Cependant, les améliorations pratiques des performances sont considérablement moindres, généralement autour de 50 %, en raison d'algorithmes logiciels et d'une mise en œuvre sous-optimaux. Une augmentation du nombre de cœurs de processeur (par exemple, dual-core, quad-core) augmente la capacité du système à gérer les charges de travail. Cela permet au processeur de gérer un plus grand volume d'événements et d'interruptions asynchrones, qui pourraient autrement solliciter le processeur en cas de surcharge. Conceptuellement, ces noyaux peuvent être assimilés à des niveaux distincts au sein d'une installation de traitement, chacun étant dédié à une tâche spécifique. Dans certains scénarios, des cœurs adjacents peuvent collaborer sur des tâches identiques si un seul cœur s'avère insuffisant pour traiter les données. Les processeurs multicœurs améliorent la capacité d'un ordinateur à exécuter plusieurs tâches simultanément en fournissant une puissance de traitement supplémentaire. Néanmoins, l'augmentation de vitesse qui en résulte n'est pas directement proportionnelle au nombre de cœurs introduits, principalement parce que la communication inter-cœurs, facilitée par des canaux spécifiques, consomme une partie de la bande passante de traitement disponible.
Les processeurs modernes possèdent des fonctionnalités avancées telles que le multithreading simultané et les architectures uncore, qui impliquent le partage des ressources réelles du processeur pour maximiser l'utilisation. Par conséquent, la surveillance des niveaux de performances et de l’utilisation du matériel est devenue une entreprise plus complexe. En réponse, certains processeurs intègrent une logique matérielle supplémentaire conçue pour suivre l'utilisation en temps réel de divers composants du processeur et fournir des compteurs accessibles par logiciel ; La technologie Performance Counter Monitor d'Intel illustre cette approche.
Overclocking
L'overclocking consiste à élever la vitesse d'horloge d'une unité centrale (CPU) et d'autres composants au-delà de leurs valeurs nominales spécifiées par le fabricant. L'augmentation de la fréquence d'horloge d'un composant entraîne un nombre plus élevé d'opérations exécutées par seconde. Cependant, l'overclocking peut entraîner des températures élevées du processeur et une surchauffe potentielle, c'est pourquoi la majorité des utilisateurs s'abstiennent de cette pratique et maintiennent les vitesses d'horloge par défaut. De plus, certaines variantes de composants, telles que les processeurs Intel de la série U ou les GPU OG de Nvidia, sont conçues pour empêcher l'overclocking.
Remarques
Remarques
Références
- Comment fonctionnent les microprocesseurs chez HowStuffWorks.
- 25 micropuces qui ont secoué le monde – article de l'Institute of Electrical and Electronics Engineers.