CPU

Le processeur, (ou CPU, Central Processing Unit, « Unité centrale de traitement » en français) est le composant essentiel d'un ordinateur qui interprète les instructions et traite les données d'un programme.

La vitesse de traitement d'un processeur est encore parfois exprimée en MIPS (million d'instructions par seconde) ou en Mégaflops (millions de floating-point operations per second) pour la partie virgule flottante, dite FPU (Floating Point Unit). Pourtant, aujourd'hui, les processeurs sont basés sur différentes architectures et techniques de parallélisation des traitements qui ne permettent plus de déterminer simplement leurs performances. Des programmes spécifiques d'évaluation des performances (benchmarks) ont été mis au point pour obtenir des comparatifs des temps d'exécution de programmes réels.

C'est le processeur qui apporte aux ordinateurs leur capacité fondamentale à être programmés, c'est un des composants nécessaires au fonctionnement de tous les types d'ordinateurs, associés aux mémoires primaires et aux dispositifs d'entrée/sortie. Un processeur construit en un seul circuit intégré est communément nommé microprocesseur, à l'inverse, certains fabricants ont développé des processeurs en tranches, dans ce cas les fonctions élémentaires (ALU, FPU, séquenceur, etc.) sont réparties dans plusieurs circuits intégrés spécialisés.

L'invention du transistor en 1947 a ouvert la voie de la miniaturisation des composants électroniques et le terme d'unité centrale (CPU) est utilisé dans l'industrie électronique dès le début des années 1960 (Weik 1961). Depuis le milieu des années 1970, la complexité et la puissance des microprocesseurs n'a cessé d'augmenter au-delà de tous les autres types de processeurs au point qu'aujourd'hui les termes de processeur, microprocesseur ou CPU, s'utilisent de manière indifférenciée pour tous les types de processeurs.

Les processeurs des débuts étaient conçus spécifiquement pour un ordinateur d'un type donné. Cette méthode coûteuse de conception des processeurs pour une application spécifique a conduit au développement de la production de masse de processeurs qui conviennent pour un ou plusieurs usages. Cette tendance à la standardisation qui débuta dans le domaine des ordinateurs centraux (mainframes à transistors discrets et mini-ordinateurs) a connu une accélération rapide avec l'avènement des circuits intégrés. Les circuits intégrés ont permis la miniaturisation des processeurs dont les dimensions sont réduites à l'ordre de grandeur du millimètre. La miniaturisation et la standardisation des processeurs ont conduit à leur diffusion dans la vie moderne bien au-delà des usages des machines programmables dédiées. On trouve les microprocesseurs modernes partout, de l'automobile aux téléphones portables, en passant par les jouets pour enfants.

Sommaire 1 Histoire 2 Processeurs à transistors discrets ou à circuits intégrés 3 Microprocesseurs 4 Fonctionnement 4.1 Composition d'un processeur 4.2 Les opérations du processeur 5 Conception et implémentation 5.1 Le codage des nombres 5.2 Le signal d'horloge 5.3 Le surfréquençage ou surcadençage (overclocking en anglais) 5.4 Parallélisme 5.4.1 ILP : Pipelining d'instructions et architecture superscalaire 5.4.2 TLP : Exécution simultanée de programmes 6 Multiprocesseur 7 Notes 8 Références 9 Voir aussi 9.1 Articles connexes 9.2 Liens externes

Histoire

Avant l'arrivée des machines qui ressemblent aux unités centrales de traitement d'aujourd'hui, les ordinateurs tels que l'ENIAC devaient être physiquement recâblés avant d'exécuter chaque programme, c'est pour cette raison qu'on les a appelés « ordinateurs à un programme ». Puisque le terme « unité centrale de traitement » est généralement défini comme dispositif d'exécution de logiciel (programme machine), les premiers dispositifs que l'on pourrait appeler processeur sont arrivés avec les ordinateurs à programme enregistré.

L'idée d'un ordinateur à programme enregistré était déjà présente pendant la conception d'ENIAC, mais avait été volontairement écartée pour que la machine soit terminée plus tôt. Le 30 juin 1945, avant qu'ENIAC ait été achevé, le mathématicien John von Neumann a diffusé le document intitulé « première ébauche d'un rapport sur l'EDVAC. » Il a décrit la conception d'un ordinateur à programme enregistré qui sera par la suite complété en août 1949 ^{[réf 1]}. EDVAC a été conçu pour exécuter un certain nombre d'instructions (ou opérations) de divers types. Ces instructions pouvaient être combinées pour créer des programmes utiles au fonctionnement de l'EDVAC. De manière significative, les programmes écrits pour EDVAC ont été stockés dans de la mémoire d'ordinateur à grande vitesse plutôt que définis par le câblage physique de l'ordinateur. Ceci a surmonté une limitation importante d'ENIAC, qui était la grande quantité de temps et d'effort nécessaires pour modifier l'ordinateur en vue d'exécuter un nouveau programme. Avec la conception de von Neumann, le programme, ou le logiciel, qu'EDVAC exécutait pouvait être changé par simple modification du contenu de la mémoire d'ordinateur ^[1] .

Tandis que von Neumann le plus souvent est crédité de la conception de l'ordinateur à programme enregistré en raison de sa conception d'EDVAC, d'autres avant lui tel que Konrad Zuse avaient suggéré des idées semblables. De plus, l'architecture de Harvard (Harvard Mark I), qui a été réalisée avant EDVAC, a également utilisé une conception à programme enregistré en utilisant le ruban perforé plutôt que la mémoire électronique. La différence principale entre les architectures von Neumann et Harvard est que la dernière sépare le stockage et le traitement des instructions et des données d'unité centrale de traitement, tandis que l'autre utilise le même espace mémoire pour les deux. La plupart des unités centrales de traitement modernes sont principalement von Neumann dans la conception, mais des éléments de l'architecture de Harvard y sont généralement ajoutés.

Comme tous les dispositifs numériques, les processeurs traitent des états discrets et requièrent donc des éléments de commutation pour différencier et changer ces états. Avant l'acceptation commerciale du transistor, les relais électromécaniques et les tubes électroniques étaient utilisés généralement comme éléments de commutation. Bien que ceux-ci présentent des avantages certains de vitesse sur les précédents, de conception purement mécanique, ils étaient peu fiables pour différentes raisons. Par exemple, réaliser des circuits de logique séquentielle à courant continu avec des relais impose du matériel additionnel pour régler le problème du rebond de contact. Tandis que les tubes à vide ne souffrent pas du rebond de contact, ils doivent être préchauffés avant de devenir complètement opérationnels et par la suite peuvent cesser de fonctionner brutalement. Régulièrement, quand un tube tombe en panne il faut procéder à un diagnostic de l'unité centrale de traitement en localisant et en remplaçant l'élément défaillant. Par conséquent, les ordinateurs électroniques plus récents (utilisant des tubes à vide) étaient généralement plus rapides mais moins fiables que les anciens (utilisant des relais) ordinateurs électromécaniques. Les ordinateurs à tubes comme EDVAC fonctionnaient en moyenne huit heures entre les pannes, tandis que les ordinateurs à relais (plus lents mais arrivés plus tôt) d'architecture Harvard ne tombaient en panne que très rarement (Weik 1961:238). En fin de compte, les unités centrales de traitement à tubes ont supplanté les autres parce que leurs avantages significatifs de vitesse ont été prépondérants par rapport aux problèmes de fiabilité. La plupart de ces premières unités centrales de traitement synchrones ont fonctionné à de basses fréquences de base comparées aux conceptions microélectroniques modernes. Les fréquences de signal d'horloge s'étendant de 100 kilohertz à 4 mégahertz étaient très communes à l'époque, limitées en grande partie par la vitesse des dispositifs de commutation qu'elles utilisaient.

Processeurs à transistors discrets ou à circuits intégrés

La complexité de conception des unités centrales de traitement s'est accrue lorsque diverses technologies ont facilité la construction de dispositifs électroniques plus petits et plus fiables. La première de ces améliorations est apparue avec l'avènement du transistor. Les processeurs transistorisés des années 1950 et des années 1960 n'ont plus besoin de faire appel à des éléments de commutation encombrants, peu fiables et fragiles comme les tubes à vide et les relais électromécaniques. Avec cette amélioration, des unités centrales de traitement plus complexes et plus fiables ont été construites sur une ou plusieurs cartes de circuit imprimé contenant des composants discrets (individuels). Au cours de cette période, une nouvelle méthode de fabrication a vu le jour, permettant de grouper un grand nombre de transistors sur une surface réduite de matériau semi-conducteur, le circuit intégré (IC) était né.

Au tout début, des circuits numériques non spécialisés, tels que les portes NOR, ont été miniaturisés dans des circuits intégrés. Les unités centrales de traitement basées sur ces modules élémentaires sont généralement appelés dispositifs à faible intégration (SSI, pour Small Scale Integration). Les circuits intégrés SSI, comme ceux utilisés dans l'ordinateur de guidage de la station spatiale Apollo, ne comptent généralement qu'une dizaine de transistors. Construire une unité centrale de traitement entièrement en circuits SSI nécessite des milliers de circuits intégrés individuels, mais consomme toujours beaucoup moins d'espace et de puissance que les montages à transistors discrets précédents. Pendant que la technologie microélectronique avançait, un nombre croissant de transistors ont été intégrés dans les circuits, de ce fait diminuant le nombre de circuits individuels nécessaires pour une unité centrale de traitement complète.

L'échelle d'intégration définit le nombre de portes par boîtier :

• SSI (small scale integration) petite : inférieur à 12 ;
• MSI (medium scale integration) moyenne : 12 à 99 ;
• LSI (large scale integration) grande : 100 à 9 999 ;
• VLSI (very large scale integration) très grande : 10 000 à 99 999 ;
• ULSI (ultra large scale integration) ultra grande : 100 000 et plus.

Ces distinctions ont peu à peu perdu de leur utilité avec la croissance exponentielle du nombre de portes logique. Aujourd'hui plusieurs centaines de millions de transistors (plusieurs dizaines de millions de portes logique) représentent un chiffre normal (pour un microprocesseur ou un circuit intégré graphique haut de gamme).

En 1964 IBM a présenté son architecture d'ordinateur System/360, qui a été employée dans une série d'ordinateurs qui pouvaient exécuter les mêmes programmes à différentes vitesses et performances. C'était significatif à un moment où la plupart des ordinateurs étaient incompatibles entre eux, même ceux construits par le même fabricant. Pour développer cette avancée, IBM mis au point le concept de microprogramme (souvent appelé « microcode »), dont l'utilisation est encore fréquente dans des unités centrales de traitement modernes. L'architecture System/360 était si populaire qu'elle a dominé le marché des ordinateurs centraux pendant plusieurs décennies laissant un héritage encore utilisé par des ordinateurs modernes comme les zSeries d'IBM. Au cours de la même année (1964), Digital Equipment Corporation (DEC) a présenté un autre ordinateur déterminant destiné au marché des ordinateurs scientifiques et de recherche, le PDP-8. DEC lancera plus tard la famille très populaire des PDP-11 qui fut à l'origine basée sur des circuits intégrés SSI puis finalement dotée de circuits LSI dès que ceux-ci furent disponibles. Contrastant avec ses prédécesseurs SSI et MSI, la première implémentation en LSI du PDP-11 comportait une unité centrale de traitement à seulement quatre circuits intégrés.

Les ordinateurs à transistors avaient plusieurs avantages certains par rapport à leurs prédécesseurs. Hormis la meilleure fiabilité et la moindre consommation d'énergie, les transistors ont permis aux processeurs de fonctionner à des vitesses beaucoup plus élevées car les temps de commutation des transistors sont beaucoup plus courts que ceux des tubes et des relais. Grâce à ces deux avancées, la fréquence d'horloge des processeurs s'est accrue considérablement pour atteindre plusieurs gigahertz. Alors que les processeurs à transistors et à circuits intégrés étaient d'usage courant, de nouveaux concepts d'architecture à haute performance comme les processeurs vectoriels et le SIMD (Simple Instruction Multiple Data - données multiples instruction simple) commencèrent à apparaître et ouvrirent la voie au développement des supercalculateurs spécialisés comme ceux qui furent réalisés par la société Cray Research.

Microprocesseurs

L'introduction du microprocesseur dans les années 1970 a marqué de manière significative la conception et l'implémentation des unités centrales de traitement. Depuis l'introduction du premier microprocesseur (Intel 4004) en 1970 et du premier microprocesseur employé couramment (Intel 8080) en 1974, cette classe de processeurs a presque totalement dépassé toutes les autres méthodes d'implémentation d'unité centrale de traitement. Les fabricants d'ordinateurs centraux (mainframe et miniordinateurs) de l'époque ont lancé leurs propres programmes de développement de circuits intégrés pour mettre à niveau les architectures anciennes de leurs ordinateurs et ont par la suite produit des microprocesseurs à jeu d'instructions compatible en assurant la compatibilité ascendante avec leurs anciens modèles. Les générations précédentes des unités centrales de traitement comportaient un assemblage de composants discrets et de nombreux circuits faiblement intégrés sur une ou plusieurs cartes électroniques. Les microprocesseurs sont construits avec un très petit nombre de circuits très fortement intégrés (ULSI), habituellement un seul. Les microprocesseurs sont implémentés sur une seule puce électronique, donc de dimensions réduites, ce qui veut dire des temps de commutation plus courts liés à des facteurs physiques comme par exemple la diminution de la capacité parasite des portes. Ceci a permis aux microprocesseurs synchrones d'augmenter leur fréquence de base de quelques dizaines de mégahertz à plusieurs gigahertz. De plus, à mesure que la capacité de fabriquer des transistors extrêmement petits sur un circuit intégré a augmenté, la complexité et le nombre de transistors dans un seul processeur a considérablement augmenté. Cette tendance largement observée est décrite par la loi de Moore, qui s'est avérée être jusqu'ici un facteur prédictif assez précis de la croissance de la complexité des processeurs (et de tout autre circuit intégré).

Les processeurs multi cœur (multicores) récents comportent maintenant plusieurs cœurs dans un seul circuit intégré, leur efficacité dépend grandement de la topologie d'interconnexion entre les cœurs. De nouvelles approches comme la superposition de la mémoire et du cœur de processeur (memory stacking) sont à l'étude et devraient conduire à un nouvel accroissement des performances. En se basant sur les tendances des 10 dernières années, les performances des processeurs devraient atteindre le Pétaflop, vers 2010 pour les serveurs, et à l'horizon 2030 dans les PC.

Début juin 2008 le supercalculateur militaire IBM Roadrunner est le premier à franchir cette barre symbolique du Pétaflop. Puis en novembre 2008 c'est au tour du supercalculateur Jaguar de Cray. En avril 2009 ce sont les deux seuls supercalculateurs à avoir dépassé le Petaflop.

Tandis que la complexité, la taille, la construction, et la forme générale des processeurs ont fortement évolué au cours des soixante dernières années, la conception et la fonction de base n'ont pas beaucoup changé. Presque tous les processeurs communs d'aujourd'hui peuvent être décrits très précisément comme machines à programme enregistré de von Neumann. Alors que la loi de Moore, mentionnée ci-dessus, continue à être vérifiée, des questions ont surgi au sujet des limites de la technologie des circuits intégrés à transistors. La miniaturisation des portes électroniques est si importante que les effets de phénomènes comme l'électromigration (dégradation progressive des interconnexions métalliques entraînant une diminution de la fiabilité des circuits intégrés) et les courants de fuite (leur importance augmente avec la réduction des dimensions des circuits intégrés, ils sont à l'origine d'une consommation d'énergie électrique pénalisante), auparavant négligeables, deviennent de plus en plus significatifs. Ces nouveaux problèmes sont parmi les nombreux facteurs conduisant les chercheurs à étudier d'une part, de nouvelles technologies de traitement telles que l'ordinateur quantique l'usage du calcul parallèle, et d'autre part, d'autres méthodes d'utilisation du modèle classique de von Neumann.

Fonctionnement

Composition d'un processeur

Les parties essentielles d’un processeur sont :

• l’Unité Arithmétique et Logique (UAL, en anglais Arithmetic and Logical Unit - ALU), qui prend en charge les calculs arithmétiques élémentaires et les tests ;
• l'unité de contrôle ou séquenceur, qui permet de synchroniser les différents éléments du processeur. En particulier, il initialise les registres lors du démarrage de la machine et il gère les interruptions ;
• les registres, qui sont des mémoires de petite taille (quelques octets), suffisamment rapides pour que l'UAL puisse manipuler leur contenu à chaque cycle de l’horloge. Un certain nombre de registres sont communs à la plupart des processeurs :
  • Compteur ordinal : ce registre contient l’adresse mémoire de l’instruction en cours d’exécution ;
  • accumulateur : ce registre est utilisé pour stocker les données en cours de traitement par l’UAL ;
  • registre d’adresses : il contient toujours l’adresse de la prochaine information à lire par l’UAL, soit la suite de l’instruction en cours, soit la prochaine instruction ;
  • registre d’instructions : il contient l’instruction en cours de traitement ;
  • registre d’état : il sert à stocker le contexte du processeur, ce qui veut dire que les différents bits de ce registre sont des drapeaux (flags) servant à stocker des informations concernant le résultat de la dernière instruction exécutée ;
  • pointeurs de pile : ce type de registre, dont le nombre varie en fonction du type de processeur, contient l’adresse du sommet de la pile (ou des piles) ;
  • registres généraux : ces registres sont disponibles pour les calculs ;
• l’horloge qui synchronise toutes les actions de l’unité centrale. Elle est présente dans les processeurs synchrones, et absente des processeurs asynchrones et des processeurs autosynchrones ;
• l'unité d’entrée-sortie, qui prend en charge la communication avec la mémoire de l’ordinateur ou la transmission des ordres destinés à piloter ses processeurs spécialisés, permettant au processeur d’accéder aux périphériques de l’ordinateur.

Les processeurs actuels intègrent également des éléments plus complexes :

• plusieurs UAL, ce qui permet de traiter plusieurs instructions en même temps. L'architecture superscalaire, en particulier, permet de disposer des UAL en parallèle, chaque UAL pouvant exécuter une instruction indépendamment de l'autre ;
• l'architecture superpipeline permet de découper temporellement les traitements à effectuer. C’est une technique qui vient du monde des supercalculateurs ;
• une unité de prédiction de saut, qui permet au processeur d’anticiper un saut dans le déroulement d’un programme, permettant d’éviter d’attendre la valeur définitive d’adresse du saut. Cela permet de mieux remplir le pipeline ;
• une unité de calcul en virgule flottante (en anglais Floating Point Unit - FPU), qui permet d’accélérer les calculs sur des nombres réels codés en virgule flottante ;
• la mémoire cache, qui permet d’accélérer les traitements, en diminuant les temps d'accès à la mémoire. Ces mémoires tampons sont en effet beaucoup plus rapides que la RAM et ralentissent moins le CPU. Le cache instructions reçoit les prochaines instructions à exécuter, le cache données manipule les données. Parfois, un seul cache unifié est utilisé pour le code et les données. Plusieurs niveaux de caches peuvent coexister, on les désigne souvent sous les noms de L1, L2 ou L3. Dans les processeurs évolués, des unités spéciales du processeur sont dévolues à la recherche, par des moyens statistiques et/ou prédictifs, des prochains accès en mémoire centrale.

Un processeur est défini par :

• la largeur de ses registres internes de manipulation de données (8, 16, 32, 64, 128) bits ;
• la cadence de son horloge exprimée en MHz (mega hertz) ou GHz (giga hertz) ;
• le nombre de noyaux de calcul (core) ;
• son jeu d'instructions (ISA en anglais, Instructions Set Architecture) dépendant de la famille (CISC, RISC, etc) ;
• sa finesse de gravure exprimée en nm (nanomètres) et sa microarchitecture.

Mais ce qui caractérise principalement un processeur est la famille à laquelle, il appartient :

• CISC (Complex Instruction Set Computer : choix d'instructions aussi proches que possible d'un langage de haut niveau) ;
• RISC ( Reduced Instruction Set Computer : choix d'instructions plus simples et d'une structure permettant une exécution très rapide) ;
• VLIW (Very Long Instruction Word) ;
• DSP (Digital Signal Processor). Même si cette dernière famille (DSP) est relativement spécifique. En effet un processeur est un composant programmable et est donc a priori capable de réaliser tout type de programme. Toutefois, dans un souci d'optimisation, des processeurs spécialisés sont conçus et adaptés à certains types de calculs (3D, son, etc.). Les DSP sont des processeurs spécialisés pour les calculs liés au traitement de signaux. Par exemple, il n'est pas rare de voir implémenter des Transformées de Fourier dans un DSP.

Un processeur possède trois types de bus :

• un bus de données, définit la taille des données manipulables (indépendamment de la taille des registres internes) ;
• un bus d'adresse définit le nombre de cases mémoire accessibles ;
• un bus de contrôle définit la gestion du processeur IRQ, RESET etc.

Les opérations du processeur

Le rôle fondamental de la plupart des unités centrales de traitement, indépendamment de la forme physique qu'elles prennent, est d'exécuter une série d'instructions stockées appelées "programme".

Les instructions (parfois décomposées en micro instructions) et les données transmises au processeur sont exprimées en mots binaires (code machine). Elles sont généralement stockées dans la mémoire. Le séquenceur ordonne la lecture du contenu de la mémoire et la constitution des mots présentées à l'ALU qui les interprète.

L’ensemble des instructions et des données constitue un programme.

Le langage le plus proche du code machine tout en restant lisible par des humains est le langage d’assemblage, aussi appelé langage assembleur (forme francisée du mot anglais « assembler »). Toutefois, l’informatique a développé toute une série de langages, dits de haut niveau (comme le BASIC, Pascal, C, C++, Fortran, Ada, etc), destinés à simplifier l’écriture des programmes.

Les opérations décrites ici sont conformes à l'architecture de von Neumann. Le programme est représenté par une série d'instructions qui réalisent des opérations en liaison avec la mémoire vive de l'ordinateur. Il y a quatre étapes que presque toutes les architectures von Neumann utilisent :

• FETCH (Recherche de l'instruction) ;
• DECODE (Décodage de l'instruction : opérations et opérandes) ;
• EXECUTE (Exécution des opérations) ;
• WRITEBACK (Ecriture du résultat).

La première étape, FETCH (recherche), consiste à rechercher une instruction dans la mémoire vive de l'ordinateur. L'emplacement dans la mémoire est déterminé par le compteur de programme (PC), qui stocke l'adresse de la prochaine instruction dans la mémoire de programme. Après qu'une instruction a été recherchée, le PC est incrémenté par la longueur du mot d'instruction. Dans le cas de mot de longueur constante simple, c'est toujours le même nombre. Par exemple, un mot de 32 bits de longueur constante qui emploie des mots de 8 bits de mémoire incrémenterait toujours le PC par 4 (excepté dans le cas des sauts). Le jeu d'instructions qui emploie des instructions de longueurs variables comme l'x86, incrémentent le PC par le nombre de mots de mémoire correspondant à la dernière longueur d'instruction. En outre, dans des unités centrales de traitement plus complexes, l'incrémentation du PC ne se produit pas nécessairement à la fin de l'exécution d'instruction. C'est particulièrement le cas dans des architectures fortement parallélisées et superscalaires. Souvent, la recherche de l'instruction doit être opérée dans des mémoires lentes, ralentissant l'unité centrale de traitement qui attend l'instruction. Cette question est en grande partie résolue dans les processeurs modernes par l'utilisation de caches et d'architectures pipelines.

L'instruction que le processeur recherche en mémoire est utilisée pour déterminer ce que le CPU doit faire. Dans l'étape DECODE (décodage), l'instruction est découpée en plusieurs parties telles qu'elles puissent être utilisées par d'autres parties du processeur. La façon dont la valeur de l'instruction est interprétée est définie par le jeu d'instructions (ISA) du processeur ^[2]. Souvent, une partie d'une instruction, appelée opcode (code d'opération), indique quelle opération est à faire, par exemple une addition. Les parties restantes de l'instruction comportent habituellement les autres informations nécessaires à l'exécution de l'instruction comme par exemples les opérandes de l'addition. Ces opérandes peuvent prendre une valeur constante, appelée valeur immédiate, ou bien contenir l'emplacement où retrouver (dans un registre ou une adresse mémoire) la valeur de l'opérande, suivant le mode d'adressage utilisé. Dans les conceptions anciennes, les parties du processeur responsables du décodage étaient fixes et non modifiables car elles étaient codées dans les circuits. Dans les processeurs plus récents, un microprogramme est souvent utilisé pour traduire les instructions en différents ordres. Ce microprogramme est parfois modifiable pour changer la façon dont le CPU décode les instructions, même après sa fabrication.

Après les étapes de recherche et de décodage arrive l'étape EXECUTE (exécution) de l'instruction. Au cours de cette étape, différentes parties du processeur sont mises en relation pour réaliser l'opération souhaitée. Par exemple, pour une addition, l'unité arithmétique et logique (ALU) sera connectée à des entrées et des sorties. Les entrées présentent les nombres à additionner et les sorties contiennent la somme finale. L'ALU contient la circuiterie pour réaliser des opérations d'arithmétique et de logique simples sur les entrées (addition, opération sur les bits). Si le résultat d'une addition est trop grand pour être codé par le processeur, un signal de débordement est positionné dans un registre d'état (voir ci-dessous le chapitre sur le codage des nombres).

La dernière étape WRITEBACK (écriture du résultat), écrit tout simplement les résultats de l'étape d'exécution en mémoire. Très souvent, les résultats sont écrits dans un registre interne au processeur pour bénéficier de temps d'accès très courts pour les instructions suivantes. Dans d'autres cas, les résultats sont écrits plus lentement dans des mémoires RAM, donc à moindre coût et acceptant des codages de nombres plus grands.

Certains types d'instructions manipulent le compteur de programme plutôt que de produire directement des données de résultat. Ces instructions sont appelées des sauts (jumps) et permettent de réaliser des boucles (loops), des programmes à exécution conditionnelle ou des fonctions (sous-programmes) dans des programmes ^[3]. Beaucoup d'instructions servent aussi à changer l'état de drapeaux (flags) dans un registre d'état. Ces états peuvent être utilisés pour conditionner le comportement d'un programme, puisqu'ils indiquent souvent la fin d'exécution de différentes opérations. Par exemple, une instruction de comparaison entre deux nombres va positionner un drapeau dans un registre d'état suivant le résultat de la comparaison. Ce drapeau peut alors être réutilisé par une instruction de saut pour poursuivre le déroulement du programme.

Après l'exécution de l'instruction et l'écriture des résultats, tout le processus se répète, le prochain cycle d'instruction recherche la séquence d'instruction suivante puisque le compteur de programme avait été incrémenté. Si l'instruction précédente était un saut, c'est l'adresse de destination du saut qui est enregistrée dans le compteur de programme. Dans des processeurs plus complexes, plusieurs instructions peuvent être recherchées, décodées et exécutées simultanément, on parle alors d'architecture pipeline, aujourd'hui communément utilisée dans les équipements électroniques.

Conception et implémentation

Le codage des nombres

La manière dont un CPU représente les nombres est un choix de conception qui affecte de façon profonde son fonctionnement de base. Certains des ordinateurs les plus anciens utilisaient un modèle électrique du système numérique décimal (base 10). Certains autres ont fait le choix de systèmes numériques plus exotiques comme les systèmes trinaires (base 3). Les processeurs modernes représentent les nombres dans le système binaire (base 2) dans lequel chacun des chiffres est représenté par une grandeur physique qui ne peut prendre que 2 valeurs comme une tension électrique "haute" ou "basse".

Le concept physique de tension électrique est analogique par nature car elle peut prendre une infinité de valeurs. Pour les besoins de représentation physique des nombres binaires, les valeurs des tensions électriques sont définies comme des états 1 et 0. Ces états résultent des paramètres opérationnels des éléments de commutation qui composent le processeur comme les niveaux de seuil des transistors.

En plus du système de représentation des nombres, il faut s'intéresser à la taille et la précision des nombres qu'un processeur peut manipuler. Dans le cas d'un processeur binaire, un "bit" correspond à une position particulière dans les nombres que le processeur peut gérer. Le nombre de bits (chiffres) qu'un processeur utilise pour représenter un nombre est souvent appelé "taille du mot" (word size, bit width, data path width) ou "précision entière" lorsqu'il s'agit de nombres entiers (à l'opposé des nombres flottants). Ce nombre diffère suivant les architectures, et souvent, suivant les différents modules d'un même processeur. Par exemple, un CPU 8-bit gère des nombres qui peuvent être représentés par 8 chiffres binaires (chaque chiffre pouvant prendre 2 valeurs), soit 2⁸ ou 256 valeurs discrètes. En conséquence, la taille du nombre entier défini une limite à la plage des nombres entiers que le logiciel exécuté par le processeur pourra utiliser.

La taille du nombre entier affecte également le nombre d'emplacements mémoire que le processeur peut adresser (localiser). Par exemple, si un processeur binaire utilise 32 bits pour représenter une adresse mémoire et que chaque adresse mémoire est représentée par un octet (8 bits), la taille mémoire maximum qui peut être adressée par ce processeur est de 2³² octets, ou 4 Gio. C'est une vision très simpliste de l'espace d'adressage d'un processeur et beaucoup de conceptions utilisent des types d'adressages bien plus complexes, comme la pagination, pour adresser plus de mémoire que la taille du nombre entier le leur permettrait avec un espace d'adressage à plat.

De plus grandes plages de nombres entiers nécessitent plus de structures élémentaires pour gérer les chiffres additionnels, conduisant à plus de complexité, des dimensions plus importantes, plus de consommation d'énergie et des coûts plus élevés. Il n'est donc pas rare de rencontrer des microcontrôleurs 4-bit ou 8-bit dans des applications modernes, même si des processeurs 16-bit, 32-bit, 64-bit et même 128-bit sont disponibles. Pour bénéficier des avantages à la fois des tailles d'entier courtes et longues, beaucoup de CPU sont conçus avec différentes largeurs d'entiers dans différentes parties du composant. Par exemple, le System/370 d'IBM est doté d'un CPU nativement 32-bit mais qui utilise une unité de calcul flottant (FPU) de 128-bit de précision pour atteindre une plus grande précision dans les calculs avec les nombres flottants. Beaucoup des processeurs les plus récents utilisent une combinaison comparable de taille de nombres, spécialement lorsque le processeur est dédié à un usage généraliste pour lequel il est nécessaire de trouver le juste équilibre entre les capacités à traiter les nombres entiers et les nombres flottants.

Le signal d'horloge

La plupart des processeurs, et plus largement la plupart des circuits de logique séquentielle, ont un fonctionnement synchrone par nature ^[4]. Cela veut dire qu'ils sont conçus et fonctionnent au rythme d'un signal de synchronisation. Ce signal, qu'on appelle généralement signal d'horloge, prend souvent la forme d'une onde carrée périodique. En calculant le temps maximum que prend le signal électrique pour se propager dans les différentes branches des circuits du processeur, le concepteur peut sélectionner la période appropriée du signal d'horloge.

Cette période doit être supérieure au temps que prend le signal pour se propager dans le pire des cas. En fixant la période de l'horloge à une valeur bien au-dessus du pire des cas de temps de propagation, il est possible de concevoir entièrement le processeur et la façon dont il déplace les données autour des "fronts" montants ou descendants du signal d'horloge. Ceci a pour avantage de simplifier significativement le processeur tant du point de vue de sa conception que de celui du nombre de ses composants. Par contre, ceci a pour inconvénient le ralentissement du processeur puisque sa vitesse doit s'adapter à celle de son élément le plus lent, même si d'autres parties sont beaucoup plus rapides. Ces limitations sont largement compensées par différentes méthodes d'accroissement du parallélisme des processeurs (Voir ci-dessous).

Les améliorations d'architecture ne peuvent pas, à elles seules, résoudre tous les inconvénients des processeurs globalement synchrones. Par exemple, un signal d'horloge est sujet à des retards comme tous les autres signaux électriques. Les fréquences d'horloge plus élevées que l'on trouve dans les processeurs à la complexité croissante engendrent des difficultés pour conserver le signal d'horloge en phase (synchronisé) à travers toute l'unité centrale de traitement. En conséquence, beaucoup des processeurs d'aujourd'hui nécessitent la fourniture de plusieurs signaux d'horloge identiques de façon à éviter que le retard d'un seul signal ne puisse être la cause d'un dysfonctionnement du processeur. La forte quantité de chaleur qui doit être dissipée par le processeur constitue un autre problème majeur dû à l'accroissement des fréquences d'horloge. Les changements d'état fréquents de l'horloge font commuter un grand nombre de composants, qu'ils soient ou non utilisés à cet instant. En général, les composants qui commutent utilisent plus d'énergie que ceux qui restent dans un état statique. ainsi, plus les fréquences d'horloge augmentent et plus la dissipation de chaleur en fait autant, ce qui fait que les processeurs requièrent des solutions de refroidissement plus efficaces.

La méthode dite de clock gating permet de gérer la commutation involontaire de composants en inhibant le signal d'horloge sur les éléments choisis mais cette pratique est difficile à implémenter et reste réservée aux besoins de circuits à très faible consommation.

Une autre méthode consiste à invalider le signal global d'horloge, la consommation d'énergie et la dissipation thermique sont réduites mais la conception du circuit devient plus complexe. Certaines conceptions ont été réalisés sans signal global d'horloge, comme par exemple les familles de processeurs ARM ou MIPS, d'autres ne présentent que des parties asynchrones comme par exemple l'utilisation d'un ALU asynchrone avec un pipelining superscalaire pour atteindre des gains de performance dans les calculs arithmétiques. Il n'est pas certain qu'un processeur totalement asynchrone puisse délivrer un niveau de performance comparable ou supérieur à un processeur synchrone alors qu'il est évident qu'il sera meilleur dans les opérations mathématiques simples, il sera donc plutôt réservé aux applications embarquées (ordinateurs de poche, consoles de jeux...).

Le surfréquençage ou surcadençage (overclocking en anglais)

L'overclocking aussi noté o/c est une méthode qui consiste pour l'utilisateur à augmenter la fréquence de l'horloge du processeur (ou, plus généralement, d'un composant) pour bénéficier de plus de performances.

Le fonctionnement des composants à une vitesse supérieure à leur vitesse nominale est possible dans certaines limites non garanties et souvent non documentées par les constructeurs. La mise au point de tels systèmes s'avère donc délicate et nécessite une démarche progressive et empirique, notamment pour la définition des moyens de refroidissement complémentaires.

Parallélisme

La description du mode de fonctionnement de base d'un processeur présentée au chapitre précédent présente la forme la plus simple que peut prendre un CPU. Ce type de processeur, appelé subscalaire, exécute une instruction sur un ou deux champs de données à la fois.

Ce processus est inefficace et inhérent aux processeurs subscalaires. Puisqu'une seule instruction n'est exécutée à la fois, tout le processeur attend la fin du traitement de cette instruction avant de s'intéresser à la suivante avec pour conséquence que le processeur reste figé sur les instructions qui nécessitent plus d'un cycle d'horloge pour s'exécuter. L'ajout d'une seconde unité de traitement (voir ci-dessous), ne permet pas d'améliorer notablement les performances, ce n'est plus une unité de traitement qui se trouve figée mais 2, en augmentant encore le nombre de transistors inutilisés. Ce type de conception, dans laquelle les ressources d'exécution du CPU ne traitent qu'une seule instruction à la fois ne peut atteindre que des performances scalaires (une instruction par cycle d'horloge), voire subscalaires (moins d'une instruction par cycle d'horloge).

En tentant d'obtenir des performances scalaires et au-delà, on a abouti à diverses méthodes qui conduisent le CPU a un comportement moins linéaire et plus parallèle. Lorsqu'on parle de parallélisme de processeur, deux termes sont utilisés pour classifier ces techniques de conception :

• Instruction Level Parallelism (ILP) - Parallélisme au niveau instruction ;
• Thread Level Parallelism (TLP) - Parallélisme au niveau thread (groupe d'instructions).

L'ILP cherche à augmenter la vitesse à laquelle les instructions sont exécutées par un CPU (c’est-à-dire augmenter l'utilisation des ressources d'exécution présentes dans le circuit intégré). L'objectif du TLP est d'accroître le nombre de threads que le CPU pourra exécuter simultanément. Chaque méthode diffère de l'autre d'une part, par la façon avec laquelle elle est implémentée et d'autre part, du fait de leur efficacité relative à augmenter les performances des processeurs pour une application.

ILP : Pipelining d'instructions et architecture superscalaire

Une des méthodes les plus simples pour accroître le parallélisme consiste à démarrer les premières étapes de recherche (fetch) et décodage (decode) d'une instruction avant la fin d'exécution de l'instruction précédente. C'est la forme la plus simple de la technique de pipelining, elle est utilisée dans la plupart des processeurs modernes non spécialisés. Le pipelining permet d'exécuter plus d'une instruction à la fois en décomposant le chemin d'exécution en différentes étapes. Ce découpage peut être comparé à une chaîne d'assemblage.

Le pipelining peut créer des conflits de dépendance de données, lorsque le résultat de l'opération précédente est nécessaire à l'exécution de l'opération suivante. Pour résoudre ce problème, un soin particulier doit être apporté pour vérifier ce type de situation et retarder, le cas échéant, une partie du pipeline d'instruction. Naturellement, les compléments de circuits à apporter pour cela ajoutent à la complexité des processeurs parallèles. Un processeur parallèle peut devenir presque scalaire, ralenti uniquement par les attentes du pipeline (une instruction prend moins d'un cycle d'horloge par étape).

Les développements suivants du pipelining ont conduit au développement d'une méthode qui diminue encore plus les temps d'attente des composants du processeur. Les conceptions dites superscalaires comportent un pipeline à instruction longue et plusieurs unités d'exécution identiques ^{[réf 2]}. Dans un pipeline superscalaire, plusieurs instructions sont lues et transmises à un répartisseur qui décide si les instructions seront exécutées en parallèle (simultanément) ou non. Le cas échéant, les instructions sont réparties sur les unités d'exécution disponibles. En général, plus un processeur superscalaire est capable d'exécuter d'instructions en parallèle et plus le nombre d'instructions exécutées dans un cycle sera élevé.

La plupart des difficultés rencontrées dans la conception des architectures de processeurs superscalaires résident dans la mise au point du répartisseur. Le répartisseur doit être disponible rapidement et être capable de déterminer sans erreur si les instructions peuvent être exécutées en parallèle, il doit alors les distribuer de façon à charger les unités d'exécution autant qu'il est possible. Pour cela, le pipeline d'instructions doit être rempli aussi souvent que possible, créant le besoin d'une quantité importante de mémoire cache. Les techniques de traitement aléatoire comme la prédiction de branchement, l'exécution spéculative et la résolution des dépendances aux données deviennent cruciales pour maintenir un haut niveau de performance. En tentant de prédire quel branchement (ou chemin) une instruction conditionnelle prendra, le processeur peut minimiser le nombre de fois que tout le pipeline doit attendre jusqu'à la fin d'exécution de l'instruction conditionnelle. L'exécution spéculative améliore les performances modestes en exécutant des portions de code qui seront, ou ne seront pas, nécessaires à la suite d'une instruction conditionnelle. La résolution de la dépendance aux données est obtenue en réorganisant l'ordre dans lequel les instructions sont exécutées en optimisant la disponibilité des données.

Lorsque seule une partie de processeur est superscalaire, la partie qui ne l'est pas rencontre des problèmes de performance dus aux temps d'attente d'ordonnancement. Le Pentium original (P5) disposait de 2 ALU superscalaires qui pouvaient chacune accepter une instruction par cycle. Ensuite le P5 est devenu superscalaire pour les calculs sur les nombres entiers mais pas sur les nombres à virgule flottante. Les successeurs des architectures Pentium d'Intel, les P6, ont été dotés de capacités superscalaires pour les calculs sur les nombres à virgule flottante améliorant par là leurs performances en calcul flottant.

Les conceptions de pipelining simple et superscalaires augmentent le parallélisme (ILP) des CPU en permettant à un processeur unique d'exécuter des instructions à un rythme de plus d'une instruction par cycle. La plupart des processeurs d'aujourd'hui ont au moins une partie superscalaires. Au cours des dernières années, certaines évolutions dans la conception des processeurs à fort parallélisme ne se trouvent plus dans les circuits du processeur mais ont été placées dans le logiciel ou dans son interface avec le logiciel (ISA). La stratégie des instructions très longues (very long instruction word) conduit à implémenter certains parallélismes directement dans le logiciel, cela réduit la participation du processeur au gain de performance mais en réduit la complexité.

TLP : Exécution simultanée de programmes

Une autre stratégie communément employée pour augmenter le parallélisme des processeurs consiste à introduire la capacité d'exécuter plusieurs programmes (threads) simultanément. De manière générale, les processeurs multi-threads ont été utilisés plus longtemps que les processeurs à architecture pipeline. Bon nombre des conceptions pionnières, réalisées par la société Cray Research, datant de la fin des années 1970 et des années 1980, mettaient en œuvre principalement la méthode TLP, dégageant alors de très grandes capacités de calcul (pour l'époque). En fait, le multithreading était connu dès les années 1950 (Réf : Smotherman 2005). Dans le cas des processeurs simples, les 2 méthodologies principales employées pour développer des TLP sont le multiprocessing au niveau des circuits (Chip-level multiprocessing - CMP) et le multithreading simultané (Simultaneous multithreading - SMT). À un plus haut niveau, il est d'usage de réaliser des ordinateurs avec plusieurs processeurs totalement indépendants dans des organisations de type symétrique (symetric multiprocessing - SMP)ou à accès mémoire non uniforme (non uniform memory access - NUMA). Alors que ces techniques diffèrent par les moyens qu'elles mettent en œuvre, elles visent toutes le même but : augmenter le nombre de threads qu'un processeur peut exécuter en parallèle.

Les méthodes de parallélisme CMP et SMP sont assez semblables, elles demandent plus d'effort de conception que l'utilisation de 2 ou 3 processeurs totalement indépendants. Dans le cas du CMP, plusieurs cœurs (core, en anglais) de processeurs sont intégrés dans le même boîtier, parfois même dans le même circuit intégré. Les SMP, eux, utilisent plusieurs boîtiers indépendants. NUMA est comparable au CMP mais met en œuvre un modèle d'accès mémoire non uniforme (les temps d'accès sont différents suivant que la mémoire est locale ou non locale à un processeur donné). Cette caractéristique est fondamentale dans les ordinateurs à plusieurs processeurs car pour les modèles SMP à mémoire partagée, les temps d'accès à la mémoire sont rapidement dégradés en cas d'accès simultané par plusieurs processeurs. À ce titre, NUMA est considéré comme un modèle plus évolutif en nombre de processeurs.

SMT diffère des autres améliorations de TLP puisqu'il vise à dupliquer aussi peu de portions de CPU que possible. La mise en œuvre d'une stratégie de type TLP ressemble à une architecture superscalaire et se trouve souvent utilisée dans les microprocesseurs superscalaires (comme les POWER5 d'IBM). Plutôt que de dupliquer un CPU complet, la conception SMT ne duplique que les parties nécessaires pour la recherche (fetch), le décodage, (decode) et la répartition des instructions (dispatch) ainsi que les registres non spécialisés. Ceci permet a un processeur SMT de maintenir ses unités d'exécution occupées plus souvent, en leur fournissant des instructions en provenance de 2 programmes différents. Comme on vient de la voir, le SMT est proche de l'architecture ILP superscalaire mais, plutôt que d'exécuter simultanément plusieurs instructions en provenance de 2 programmes différents, elle permet d'exécuter simultanément plusieurs instructions en provenance du même programme.

Multiprocesseur

Notes

Références

Voir aussi

Articles connexes

Liens externes

• (fr) Fonctionnement Standard d'un Processeur

• Portail de l’électricité et de l’électronique
• Portail de l’informatique