L'informatique(suite)

Le processeur

La puce d'un microprocesseur Intel 80486DX2 dans son boîtier (taille réelle: 12X6,75mm)

Le processeur, ou CPU (de l'anglais Central Processing Unit, "Unité centrale de traitement"), est le composant de l'ordinateur qui exécute les programmes informatiques. Avec la mémoire notamment, c'est l'un des composants qui existent depuis les premiers ordinateurs. Un processeur construit en un seul circuit intégré est un microporcesseur.

L'invention du transistor en 1948 a ouvert la voie à la miniaturisation des composants électroniques.

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. 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.

Microprocesseurs

Intel 80486DX2 microprocesseur en boîtier céramique PGA

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 1971 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 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é à fabriquer des transistors dans un seul processeur ont considérablement crû. 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 coeurs (multicores) récents comportent maintenant plusieurs coeurs dans un seul circuit intégré. Leur efficacité dépend grandement de la topologie d'interconnexion entre les coeurs. De nouvelles approches, comme la superposition de la mémoire et du coeur de processeur (memory stacking), sont à l'étude, et devraient conduire à un nouvel accroissement des performances. En se basant sur les tendances des dix dernières années, les performances des processeurs devraient atteindre le pétaFLOPS, vers 2010 pour les serveurs, et à l'horizon2030 dans les PC.

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

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 de se vérifier, 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 ou les chercheurs à étudier, d'une part, de nouvelles technologies de traitement telles que l'ordinateur quantique ou 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

Schéma de principe d'un processeur 32 bits

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 ou de la suivante, selon l'architecture,

.accumulateur: ce registre est utilisé pour stocker les données en cours de traitement par l'UAL,

.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 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, permettent 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,

.un pipeline permet de découper temporellement les traitements à effectuer.

.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,

.de 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, L3 ou L4. 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 possède trois types de bus:

.un bus de données, définit la taille des données pour les entrées/sorties, dont les accès à la mémoire (indépendamment de la taille des registres internes),

.un bus d'adresse permet, lors d'une lecture ou une écriture, d'envoyer l'adresse où elle s'effectue, et donc définit le nombre de cases mémoire accessibles,

.Un bus de contrôle permet la gestion du matériel, via les interruptions.

Classification des processeurs

Un processeur est défini par:

Son architecture, c'est-à-dire son comportement vu le programmeur, liée à:

-son jeu d'instructions (ISA en anglais, Instructions Set Architecture),

-la largeur de ces registres internes de manipulation de données (8,16,32,64,128) bits et leur utilisation,

-les spécifications des entrées/sorties, de l'accès à la mémoire, etc....

Ses caractéristiques, variables même entre processeurs compatibles:

-sa microarchitecture,

-la cadence de son horloge exprimée en Mhz (mégahertz) ou GHz (gigahertz),

-sa finesse de gravure exprimée en nm (nanomètres) et,

-le nombre de noyaux de calcul(coeurs)

On classe les architectures en plusieurs grandes familles:

.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.

Au contraire d'un DSP, un porcesseur softcore est un circuit logique programmable et n'a plus du tout de fonction précablée.

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és à l'ALU qui les interpè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 les 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 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ération et opérandes),

.execute- exécution de l'opération,

.writeback- écriture du résultat

Le diagramme montre comment une instruction de MIPS32 est décodée

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 les 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 les architectures fortement parallélisées et superscalaires. Souvent, la recherche de l'instruction doit être opérée dans les 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. 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.

Diagramme fonctionnel d'un processeur simple


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 a exécution conditionnelle ou des fonctions (sous-programmes) dans des programmes. 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'instructions 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.

Vitesse de traitement

La vitesse de traitement d'un processeur est encore parfois exprimée en MIPS (million d'instruction par seconde) ou en MégaFLOPS (millions de floating-point opérations 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 permettent plus de déterminer simplement leurs performances. Des programmes spécifiques d'évaluation d'évaluation des performances (benchmarks) ont été mis au point pour obtenir des comparatifs des temps d'exécution de programmes réels.

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 deux 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.

Le microprocesseur 6502 en technologie MOS dans un boîtier dual in-line une conception très répandue

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 CPU8-bit gère des nombres qui peuvent être représentés par huit chiffres binaires (chaque chiffre pouvant prendre deux valeurs), soit 2⁸ ou 256 valeurs discrètes. En conséquence, la taille du nombre entier définit 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 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çues 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 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 destiné à 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 pluaprt des processeurs, et plus largement la plupart des circuits de logique séquentielle, ont un fonctionnement synchrone par nature. Cela veut dire qu'ils conçus et fonctionnent au rythme d'un signal de synchronisation. Ce signal est le "signal d'horloge". Il 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.

Les améliorations d'architecture ne peuvent pas, à elles seules, résoudre tous les inconvénients des 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 à abandonner le signal global d'horloge, la consommation d'énergie et la dissipation thermique sont réduites mais la conception du circuit devient plus complexe. On parle alors de processeurs asychrones. Certaines conceptions ont été réalisés sans signal global d'horloge, utilisant par exemple les jeux d'instructions ARM ou MIPS, d'autres ne présentent que des parties asynchrones comme par exemple l'utilisation d'une UAL asychrone avec un "pipelining" superscalaire pour atteindre des gains de performance dans les calculs arithmétiques. De tels processeurs sont actuellement plutôt réservés aux applications embarquées (ordinateurs de poche, consoles de jeux...).

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 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 (Modèle de processeur subscalaire: il faut 15 cycles pour exécuter trois instructions), 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

Pipeline de base à 5 étages. Dans le meilleur scénario, ce pipeline peut soutenir un taux d'exécution d'une instruction par cycle.

Une des méthodes les plus simples pour accroître le parallélisme consiste à démarrer mes 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. Dans un pipeline supersclaire, plusieurs instructions sont lues et transmises à un répartisseur qui décide si les instructions seront exécutées en paraallè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 supercalaire est capable d'exécuter d'instructions en parallèle et plus le nombre d'instructions exécutées dans un cycle sera élevé.

Pipeline superscalaire simple. En recherchant et affectant deux instructions à la fois, le CPU peut exécuter un maximum de deux instructions par cycle.

La plupart des difficultés rencontrées dans la conception des architectures de processeurs superscalaires résident dans la mise au point 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 temps 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 deux 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-VLIW) 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 mutli-threads ont été utilisés depuis 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 oeuvre principalement 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 deux méthodologie principales employées pour développer des TLP sont le multiprocessing -SMP) ou à accès mémoire non uniforme (Non Uniform Memory Access-NUMA). Il s'agit alors de multiprocesseurs ou de processeurs multi-coeur. Alors que ces techniquess différent par les moyens qu'elles mettent en oeuvre, 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 deux ou trois processeurs totalement indépendants. Dans le cas du CMP, plusieurs coeurs (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 oeuvre 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. A 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 oeuvre 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, ("décode") 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 deux programmes différents. Comme on vient de la voir, le SMT est plus proche de l'architecture ILP superscalaire mais, plutôt que d'exécuter simultanément plusieurs instructions en provenance de deux programmes différents, elle permet d'exécuter simultanément plusieurs instructions en provenance du même programme.

Le processeur graphique

Un processeur graphique GeForce 6600GT de nVidia

  
Un processeur graphique, ou GPU (de l'anglais Graphics Processing Unit) est un circuit intégré présent sur une carte graphique et assurant les fonctions de calcul de l'affichage. Un processeur graphique a généralement une structure hautement parallèle qui les rend efficaces pour une large palette de tâches graphiques comme le rendu 3D, en Direct3D, en OpenGL, la gestion de la mémoire vidéo, traitement du signal vidéo, décompression Mpeg, etc...

Peu d'entreprises conçoivent de tels processeurs: NVIDIA, ATI/AMD, Intel, S3 Graphics, Matrox, 3DLabs(en), et XGI(en). D'autres entreprises (Asus, MSI, PNY...) se chargent ensuite de proposer des cartes graphiques intégrant ces processeurs.

Fonctionnement

Il faut d'abord savoir ce que sont les vertex, c'est-à-dire les données élémentaires de la géométrie en trois dimensions, points entre lesquels seront tracées les arêtes d'un objet (les vertex sont les sommets des objets en trois dimensions). Le processeur construit les objets multidimensionnels. Si les objets sont en deux dimensions, ou qu'il s'agit de vidéos, les données sont directement envoyées à la fenêtre d'affichage.

Pour accélérer le calcul, le processeur calcule les vertex invisibles (cachés par d'autres vertex, par les faces d'un objet ou autre) et les supprime pour ne pas avoir à les gérer.

Le processeur graphique applique ensuite aux faces des objets les textures puisées sur le disque dur grâce au Pixel Pipeline. Le moteur graphique envoie ensuite au processeur des données sur l'éclairage des polygones, que celui-ci se charge de mettre en oeuvre pour éclairer la scène. Ensuite, la puce graphique applique à l'image les divers filtres (anticrénelage ou filtrage anisotrope), et envoie le résultat à la fenêtre d'affichage, qui "aplatit" l'image pour afficher à l'écran.

Types:

Il existe différents types de processeurs graphiques:

Carte graphique dédiée

Il s'agit du type de processeur graphique le plus puissant. Le processeur est généralement situé sur une carte interfacée avec la carte mère de l'ordinateur par un port PCI Express pour les machines récentes AGP ou PCI pour les machines plus anciennes, quant aux ordinateurs portables, certains disposent d'une déclinaison spécifique du port PCI Express, le MXM ou Mobile PCI-Express Module). Ces cartes disposent de leur propre mémoire vive.

Il existe aussi le format PCI Express 16X qui permet maintenant de dépasser les fréquences et les quantités de mémoire qui étaient limitées par le PCI express (512MO en PCI express, la limite du PCI express 16x n'a pas encore été atteinte).

Processeur graphique intégré (IGP)

Ces processeurs graphiques sont intégrés dans le northbridge sur la carte mère de l'ordinateur ou directement au processeur central (à partir de la famille de processeurs Westmere chez Intel), et utilisant sa mémoire vive ou plus rarement une faible quantité de mémoire dédiée. Ces processeurs graphiques sont moins performants que ceux des cartes graphiques dédiées, mais ils sont moins coûteux, plus facile a intégrer et moins consommateurs en énergie. Les ordinateurs portables anciens et/ou d'entrée de gamme utilisent cette méthode afin de réduire les coûts.

Les IGP suffisent si le matériel n'est pas sollicité par les jeux modernes. Les cartes mères actuelles ont souvent un processeur graphique intégré et un (ou plusieurs) port permettant d'ajouter une carte graphique dédiée.

Le microprocesseur

Intel 4004 dans son boîtier à 16 broches

Intel 80486DX2

Un microprocesseur est un processeur dont les composants ont été suffisamment miniaturisés pour être regroupés dans un unique circuit intégré. Fonctionnellement, le processeur est la partie d'un ordinateur qui exécute les instructions et traite les données des programmes.

Description

Jusqu'au début des années 1970, les différents composants électroniques formant un processeur ne pouvaient pas tenir sur un seul circuit intégré. On devait donc les placer sur plusieurs circuits intégrés. En 1971, la société américaine Intel réussit, pour la première fois, à placer tous les transistors qui constituent un processeur sur un seul circuit intégré donnant ainsi naissance au microprocesseur.

Cette miniaturisation a permis:

.d'augmenter les vitesses de fonctionnement des processeurs, grâce à la réduction des distances entre les composants , entre autres, 

.de réduire les coûts, grâce au remplacement de plusieurs circuits par un seul, entre autres,

.d'augmenter la fiabilité: en supprimant les connexions entre les composants du processeur, on supprime l'un des principaux vecteurs de panne,

.de créer des ordinateurs bien plus petits: les micro-ordinateurs,

.de réduire la consommation énergétique.

Les principales caractéristiques d'un microprocesseur sont:

.Le jeu d'instructions qu'il peut exécuter. Voici quelques exemples d'instructions que peut exécuter un microprocesseur: additionner deux nombres, comparer deux nombres pour déterminer s'ils sont égaux, comparer deux nombres pour déterminer lequel est le plus grand, multiplier deux nombres,...Un processeur peut exécuter plusieurs dizaines, voire centaine ou milliers, d'instructions différentes.

.La complexité de son architecture. Cette complexité se mesure par le nombre de transistors contenus dans le microprocesseur. Puis le microprocesseur contient de transistors, plus il pourra effectuer des opérations complexes, et/ou traiter des chiffres de grande taille.

.Le nombre de bits que le processeur peut traiter ensemble. Les premiers microprocesseurs ne pouvaient traiter plus de 4 bits d'un coup. Ils devaient donc exécuter plusieurs instructions pour additionner des nombres de 32 ou 64 bits. Les microprocesseurs actuels (en 2007) peuvent traiter des nombres sur 64 bits ensemble. Le nombre de bits est en rapport direct avec la capacité à traiter de grands nombres rapidement, ou des nombres d'une grande précision (nombres de décimales significatives).

.La vitesse de l'horloge.Le rôle de l'horloge est de cadencer le rythme du travail du microprocesseur. Plus la vitesse de l'horloge augmente, plus le microprocesseur effectue d'instructions en une seconde.

Tout ceci est théorique, dans la pratique, selon l'architecture du processeur, le nombre de cycles d'horloge pour réaliser une opération élémentaire peut varier d'un cycle à plusieurs dizaines par unité d'exécution (typiquement une sur un processeur classique).

Par exemple, un processeur A cadencé à 400MHz peut être plus rapide qu'un autre B lui cadencé à 1GHz, tout dépend de leurs architectures respectives.

La combinaison des caractéristiques précédentes détermine la puissance du microprocesseur. La puissance d'un microprocesseur s'exprime en Millions d'Instructions Par Seconde (MIPS). Dans les années 1970, les microprocesseurs effectuaient moins d'un million d'instructions par seconde, les processeurs actuels (en 2007) peuvent effectuer plus de 10 milliards d'instructions par seconde.

Histoire

illustration de la loi de Moore, une observation de l'évolution du nombre de transistors d'un microprocesseur, de 1971 à 2011

En 1969, le microprocesseur a été inventé par deux ingénieurs d'Intel: Marcian Hoff (surnommé Ted Hoff) et Federico Faggin. Marcian Hoff a formulé l'architecture du microprocesseur (une architecture de bloc et un jeu d'instructions).

Le premier microprocesseur commercialisé, le 15 novembre 1971, est l'Intel 4004 4-bits. Il fut suivi par l'Intel 8008. Ce microprocesseur a servi initialement à fabriquer des contrôleurs graphiques en mode texte, mais jugé trop lent par le client qui en avait demandé la conception, il devint un processeur d'usage général. Ces processeurs sont les précurseurs des Intel 8080, Zilog Z80, et de la future famille des Intel X86.

Illustration de la loi dite de "progression géométrique" qui régit l'évolution du nombre de transistors sur les puces de silicium.

Federico Faggin a inventé la conception du microprocesseur (méthodologie de conception nouvelle pour la puce et la logique, fondée pour la première fois sur la technologie silicon gate développé par lui en 1968 chez Fairchild, conception de circuits et de la logique, nouveau layout, plusieurs nouvelles solutions techniques) en 1970. Federico Faggin a aussi dirigé la conception du premier microprocesseur jusqu'à son introduction sur le marché en 1971.

En 1990, Gilbert Hyatt a revendiqué la paternité du microprocesseur en se basant sur un brevet qu'il avait déposé en 1970. La reconnaissance de l'antériorité du brevet de Hyatt aurait permis à ce dernier de réclamer des redevances sur tous les microprocesseurs fabriqués de par le monde. Cependant, le brevet de Hyatt a été invalidé en 1995 par l'office américain des brevets, sur la base du fait que le microprocesseur décrit dans la demande de brevet n'avait pas été réalisé, et n'aurait d'ailleurs pas pu l'être avec la technologie disponible au moment du dépôt du brevet.

Le tableau suivant décrit les principales caractéristiques des microprocesseurs fabriqués par Intel, et montre leur rapide et systématique évolution à la fois en augmentation du nombre de transistors, en miniaturisation des circuits, et en augmentation de puissance. Il faut garder à l'esprit que si ce tableau décrit l'évolution des produits des concurrents a suivi avec plus ou moins d'avance ou de retard la même marche.

Un programme informatique est, par essence, un flux d'instructions exécutées par un processeur. Chaque instruction nécessite un à plusieurs cycles d'horloge, l'instruction est exécutée en autant d'étapes que de cycles nécessaires. Les microprocesseurs séquentiels exécutent l'instruction suivante lorsqu'ils ont terminé l'instruction en cours. Dans le cas du parallélisme d'instructions, le microprocesseur pourra traiter plusieurs instructions dans le même cycle d'horloge, à condition que ces instructions différentes ne mobilisent pas simultanément une unique ressource interne. Autrement dit, le processeur exécute des instructions qui se suivent, et ne sont pas dépendantes l'une de l'autre, à différents stades d'achèvement. Cette file d'exécution à venir s'appelle un pipeline. Ce mécanisme a été implémenté la première fois dans les années 1960 par IBM.

Les processeurs plus évolués exécutent en même temps autant d'instructions qu'ils ont de pipelines, ce à la condition que toutes les instructions à exécuter parallèlement ne soient pas interdépendantes, c'est-à-dire que le résultat de l'exécution de chacune d'entre elles ne modifie pas les conditions d'exécution de l'une des autres. Les processeurs de ce type sont appelés processeurs superscalaires. Le premier ordinateur à être équipé de ce type de processeur était le Seymour Cray CDC 6600 en 1965. Le Pentium est le premier des processeurs superscalaires pour compatible PC.

Aujourd'hui, les concepteurs de processeurs ne cherchent pas simplement à exécuter plusieurs instructions indépendantes en mêmes temps, ils cherchent à optimiser le temps d'exécution de l'ensemble des instructions. Par exemple le processeur peut trier les instructions de manière à ce que tous ses pipelines contiennent des instructions indépendantes. Ce mécanisme s'appelle l'exécution out-of-order. Ce type de processeur s'est imposé pour les machines grand public à partir des années 1980 et jusqu'aux années 1990.

L'exemple canonique de ce type de pipeline est celui d'un processeur RISC, en cinq étapes. Le Intel Pentium 4 dispose de 35 étages de pipeline. Un compilateur optimisé pour ce genre de processeur fournira un code qui sera exécuté plus rapidement.

Pour éviter une perte de temps liée à l'attente de nouvelles instructions, et surtout au délai de rechargement du contexte entre chaque changement de threads, les fondeurs ont ajouté à leurs processeurs des procédés d'optimisation pour que les threads puissent partager les pipelines, les caches et les registres. Ces procédés, regroupés sous l'appellation Simultaneous Multi Threading, ont été mis au point dans les années 1950. Par contre, pour obtenir une augmentation des performances, les compilateurs doivent prendre en compte ces procédés, il faut donc re-compiler les programmes pour ces types de processeurs. Intel a commencé à produire, début des années 2000, des processeurs implémentant la technologie SMT à deux voies. Ces processeurs, les Pentium 4, peuvent exécuter simultanément deux threads qui se partagent les mêmes pipelines, caches et registres. Intel a appelé cette technologie SMT à deux voies: l'Hyperthreading. Le Super-threading est, quant à lui, une technologie SMT dans laquelle plusieurs threads partagent aussi les mêems ressources, mais ces threads ne s'exécutent que l'un après l'autre et non simultanément.

Depuis longtemps déjà, existait l'idée de faire cohabiter plusieurs processeurs au sein d'un même composant, par exemple les System on Chip. Cela consistait, par exemple, à ajouter au processeur, un coprocesseur arithmétique, un DSP, voire un cache mémoire, éventuellement même l'intégralité des composants que l'on trouve sur une carte mère. Des processeurs utilisant deux ou quatre coeurs sont donc apparus, comme le POWER4 d'IBM sorti en 2001. Ils disposent des technologies citées préalablement. Les ordinateurs qui disposent de ce type de processeurs coûtent moins cher que l'achat d'un nombre équivalent de processeurs, cependant, les performances ne sont pas directement comparables, cela dépend du problème traité. Des API spécialisées ont été développées afin de tirer parti au mieux de ces technologies, comme le Threading Building Blocks d'Intel.

Date	Nom	Nombre de transistors	Finesse de gravure (nm)	Fréquence de l’horloge	Largeur des données	MIPS
1971	Intel 4004	2 300	10 000	108kHz	4 bits/4 bits bus	0,06
1974	Intel 8008	6 000	6 000	2MHz	8 bits/8 bits bus	0,64
1979	Intel 8088	29 000	3 000	5MHz	16 bits/8bits bus	0,33
1982	Intel 80286	134 000	1 500	6 à 16MHz (20MHz chez AMD)	16 bits/16 bits bus	1
1985	Intel 80386	275 000	1 500	16 à 40MHz	32 bits/32 bits bus	5
1989	Intel 80486	1 200 000	1 000	16 à 100MHz	32 bits/32 bits bus	20
1993	Pentium (IntelP5)	3 100 000	800 à 250	60 à 233MHz	32 bits/64 bits bus	100
1997	Pentium II	7 500 000	350 à 250	233 à 450MHz	32 bits/64 bits bus	300
1999	Pentium III	9 500 000	250 à 130	450 à 1 400MHz	32 bits/64 bits bus	510
2000	Pentium 4	42 000 000	180 à 65	1,3 à 3,8GH z	32 bits/64 bits bus	1 700
2004	Pentium 4D (Prescott)	125 000 000	90 à 65	2.66 à 3,6GHz	32 bits/64 bits bus	9 000
2006	Core 2 Duo (Conroe)	291 000 000	65	2,4GHz (E6600)	64 bits/64 bits bus	22 000
2007	Core 2 Quad (Kentsfield)	2*291 000 000	65	3GHz (Q6850)	64 bits/64 bits bus	2*22 000
2008	Core 2 Duo (Wolfdale)	410 000 000	45	3,33GHz (E8600)	64 bits/64 bits bus	~2*24 200
2008	Intel Core i7 (Bloomfield)	731 000 000	45	3,33GHz (Core i7 975X)	64 bits/64 bits bus
2009	Intel Core i5/i7 (Lynnfield)	774 000 000	45	3 06GHz (17 880)	64 bits/64 bits bus	76383
2010	Intel Core i7 (Gulftown)	1 170 000 000	32	3,47GHz (Core i7 990X)	64 bits/64 bits bus	147600
2011	Intel Core i3/i5/i7 (Sandy Bridge)	1 160 000 000	32	3,5GHz(Core i7 2700K)	64 bits/64 bits bus
2011	Intel Core i7/Xeon (Sandy Bridge-E)	2 270 000 000	32	3,5GHz (Core i7 3970K)	64 bits/64 bits bus
2012	Intel Core i3/i5/i7 (Ivy Bridge)	1 400 000 000	22	3,5GHz (Core i7 3770K)	64 bits/64 bits bus

 

.Date: l'année de commercialisation du microprocesseur

.Nom: le nom du microprocesseur

.Nombre de transistors: le nombre de transistors contenus dans le microprocesseur

.Finesse de gravure (nm): le diamètre (en nanomètres) du plus petit fil reliant deux composantes du microprocesseur. En comparaison, l'épaisseur d'un cheveu humain est de 100 microns=100 000nm

.Fréquence de l'horloge: la fréquence du signal d'horloge interne qui cadence le microprocesseur. MHz=million(s) de cycles par seconde. GHz=milliard(s) de cycles par seconde.

.Largeur des données: le premier nombre indique le nombre de bits sur lequel une opération est faite. Le second nombre indique le nombre de bits transférés à la fois entre la mémoire et le microprocesseur.

.MIPS: le nombre de millions d'instructions effectuées par le microprocesseur en une seconde

Familles de microprocesseurs


Microprocesseur PowerPC4755

Microprocesseur ARM60

Microprocesseur Intel Core 2 Duo

Les microprocesseurs sont habituellement regroupés en familles, en fonction du jeu d'instructions qu'ils exécutent. Si ce jeu d'instructions comprend souvent une base commune à toute la famille, les microprocesseurs les plus récents d'une famille peuvent présenter de nouvelles instructions. La rétrocompatibilité au sein d'une famille n'est donc pas toujours assurée. Par exemple un programme dit compatible X86 écrit pour un processeur 80386, qui permet la protection mémoire, pourrait ne pas fonctionner sur des processeurs antérieurs, mais fonctionne sur tous les processeurs plus récents (par exemple un Core Duo d'Intel ou un Athlon d'AMD).

Il existe plusieurs familles de microprocesseurs:

.La famille la plus connue par le grand public est la famille X86, développée principalement par les entreprises Intel (fabricant du Pentium), AMD (fabricant de l'Athlon), VIA et Transmeta.Les deux premières entreprises dominent le marché et elles fabriquent la plus grande part des microprocesseurs pour micro-ordinateurs compatibles PC. Intel fournit également les microprocesseurs pour les micro-ordinateurs Macintosh depuis 2006.

.Les microprocesseurs PowerPC d'IBM et de Motorola équipaient jusqu'en 2006 les micro-ordinateurs Macintosh (fabriqués par Apple). Ces microprocesseurs sont aussi utilisés dans les serveurs de la série P d'IBM et dans divers systèmes embarqués. Dans le domaine des consoles de jeu, des microprocesseurs dérivés du PowerPC équipent la Wii (Broadway), la GameCube (Gekko), Xbox360 (dérivé à trois coeurs nommé Xénon). La Playstation 3 est équipée du microprocesseur Cell, dérivé du POWER4, une architecture proche de PowerPC.

.Le microprocesseur 6502 de la société MOS Technology a servi à fabriquer le célèbre Apple II.

.Le microprocesseur Zilog Z80 a été largement utilisé dans les années 1980 dans la conception des premiers micro-ordinateurs personnels 8 bits comme le Radio Shack TRS-80, les Sinclair ZX80, ZX81, ZX Spectrum, les Apple II grâce à une carte fille, le standard MSX, les Amstrad CPC et plus tard dans les systèmes embarqués.

.La famille 6800 de la société Motorola

.La famille 68000 (aussi appelée m68k) de Motorola animait les anciens Macintosh, les Magadrive, les Atari ST et les Commodore Amiga. Leurs dérivés (Dragonball, ColdFire) sont toujours utilisés dans les systèmes embarqués.

Parmi les familles moins connues du grand public:

.La famille Sparc anime la plus grande partie des serveurs et stations de travail de Sun Microsystems, bien que de plus en plus nouveaux produits soient réalisés à base de X86.

.La famille PA-RISC de HP et VLSI Technology, anime les anciens serveurs et stations de travail de HP, remplacée aujourd'hui par la famille IA-64.

.La famille IA-64 de HP et Intel, apporte l'architecture 64 bits aux serveurs et stations de travail de HP.

.La famille MIPS anime les stations de travail de Silicon Graphics, des consoles de jeux comme les PSone, les Nintendo64 et des systèmes embarqués, ainsi que des routeurs Cisco. C'est la première famille à proposer une architecture 64 bits avec le R4000 en 1991. Les processeurs du fondateur chinois Loongson, sont une nouvelle génération basées sur les technologies du MIPS, utilisés dans les supercalculateurs et des ordinateurs faible consommation.

.Le microprocesseur APS3 spécialement conçu pour les systèmes embarqués.

.La famille ARM est de nos jours utilisée uniquement dans les systèmes embarqués, dont de nombreux PDAs et Smartphones, elle a précédemment été utilisée par Acorn pour ses Archimedes et RiscPC.

.La famille DEC Alpha animait les ordinateurs DEC, repris par Compaq puis par HP qui l'a définitivement arrêtée.

Rapidité d'exécution des instructions

Fréquence de fonctionnement

Les microprocesseurs sont cadencés par un signal d'horloge (signal oscillant régulier imposant un rythme au circuit). Au milieu des années 1980, ce signal avait une fréquence de 4 à 8MHz. Dans les années 2000, cette fréquence atteint 4GHz. Plus fréquence est élevée, plus le microprocesseur peut exécuter à un rythme élevé les instructions de base des programmes.

L'augmentation de la fréquence présente des inconvénients:

.plus elle est élevée, plus le processeur consomme d'électricité, et plus il chauffe: cela implique d'avoir une solution de refroidissement du processeur adaptée,

.la fréquence est notamment limitée par les temps de communication des portes logiques: il est nécessaire qu'entre deux "coups d'horloge", les signaux numériques aient eu le temps de parcourir tout le trajet nécessaire à l'exécution de l'instruction attendue, pour accélérer le traitement, il faut agir sur de nombreux paramètres (taille d'un transistor, interactions électromagnétiques entre les circuits, etc.....) qu'il devient de plus en plus difficile d'améliorer (tout en s'assurant de la fiabilité des opérations).

Overclocking

L'overclocking consiste à forcer l'augmentation de la fréquence du signal d'horloge du microprocesseur (par rapport aux recommandations du fabricant), afin de poucoir exécuter plus d'instructions à chaque seconde.

Optimisation du chemin d'exécution

Les microprocesseurs actuels sont optimisés pour exécuter plus d'une instruction par cycle d'horloge, ce sont des microprocesseurs avec des unités d'exécution parallélisées. De plus ils sont dotés de procédures qui "anticipent" les instructions suivantes avec l'aide de la statistique.

Dans la course à la puissance des microprocesseurs, deux méthodes d'optimisation sont en concurrence:

1.La technologie RISC (Reduced Instruction Set Computer, jeu d'instructions simple), rapide avec des instructions simples de taille standardisée, facile à fabriquer et dont on peut monter la fréquence de l'horloge sans trop de difficultés techniques.

2.La technologie CISC (Complex Instruction Set Computer), dont chaque instruction complexe nécessite plus de cycles d'horloge, mais qui a en son coeur beaucoup d'instructions pré-câblées.

Néanmoins, avec la diminution de la taille des puces électroniques et l'accélération des fréquences d'horloge, la distinction entre RISC et CISC a quasiment complètement disparu. Là où des familles tranchées existaient, on observe aujourd'hui des microprocesseurs où une structure interne RISC apporte de la puissance tout en restant compatible avec une utilisation de type CISC (la famille Intel X86 a ainsi subi une transition entre une organisation initialement très typique d'une structure CISC. Actuellement elle utilise un coeur RISC très rapide, s'appuyant sur un système de réarrangement du code à la volée) mis en oeuvre, en partie, grâce à des mémoires cache de plus en plus grandes, comportant jusqu'à trois niveaux.

Structure d'un microprocesseur

L'unité centrale d'un microprocesseur comprend essentiellement:

.une unité arithmétique et logique (U.A.L) qui effectue les opérations,

.des registres qui permettent au microprocesseur de stocker temporairement des données,

.une unité de contrôle qui commande l'ensemble du microprocesseur en fonction des instructions du programme.

Certains registres ont un rôle très particulier:

.le registre indicateur d'état (flags), ce registre donne l'état du microprocesseur à tout moment, il peut seulement être lu,

.le compteur de programme (PC, Program Counter), il contient l'adresse de la prochaine instruction à exécuter,

.le pointeur de pile (SP, Stack Pointer), c'est le pointeur d'une zone spéciale de la mémoire appelée pile où sont rangés les arguments des sous-programmes et les adresses de retour.

Seul le Program Counter est indispensable, il existe de (rares) processeurs ne comportant pas de registre d'état ou pas de pointeur de pile (par exemple le NS32000).

L'unité de contrôle peut aussi se décomposer:

.le registre d'instruction, mémorise le code de l'instruction à exécuter,

.le décodeur décode cette instruction,

.le séquenceur exécute l'instruction, c'est lui qui commande l'ensemble des organes du microprocesseur.

Fabrication des microprocesseurs

La fabrication d'un microprocesseur est essentiellement identique à celle de n'importe quel circuit intégré. Elle suit donc un procédé complexe. Mais l'énorme taille et complexité de la plupart des microprocesseurs a tendance à augmenter encore le coût de l'opération.

La loi de Moore, qui indique que le nombre de transistors des microprocesseurs sur les puces de silicum double tous les 2 ans, indique également que les coûts de production doublent en même temps que le degré d'intégration.

La fabrication des microprocesseurs est aujourd'hui considérée comme l'un des deux facteurs d'augmentation de la capacité des unités de fabrication (avec les contraintes liées à la fabrication des mémoires à grande capacité). La finesse de la gravure industrielle a atteint 45nm en 2006. En diminuant encore la finesse de gravure, les fondeurs se heurtent aux règles de la mécanique quantique.

Fonctions à développer

Organisation parallèle

Selon le système d'exploitation, la tendance actuelle est l'installation de plusieurs processeurs parallèles et de multiples tâches d'où l'importance grandissante des fonctions d'arbitrages entre processus (par exemple l'hyper threading). En effet, l'architecture super scalaire (mise en parallèle des tâches dans une unité d'exécution) des processeurs actuels ne suffit actuellement plus au multi-threading tel qu'il est utilisé.

En revanche, les processeurs à plusieurs coeurs exigent que soit étudiée de près la répartition des tâches entre eux si on veut pas voir observer un ralentissement des opérations, c'est ce qu'on nomme les affinités entre processus (processor affinity).

Sécurité et location

Il existe de nombreux projets d'intégration au coeur des microprocesseurs de fonctions visant à empêcher les copies illégales de fichiers (technologies DRM). Le consoritum Trusted Computing Group, notamment, a déjà créé des puces permettant de créer une "zone de confiance" au sein du système informatique, à l'aide d'une puce d'identification spécifique.Certains modèles d'ordinateurs, comme les portables d'IBM intègrent déjà de telles puces. La prochaine génération de cette technologie sera probablement intégrée dans les processus centraux des ordinateurs.

Ces technologies sont décriées, notamment par des partisans du logiciel libre, pour qui elles possèdent un potentiel liberticide. En effet, conjuguées à un système d'exploitation prévu à cet effet, par exemple dérivé du projet NGSCB de Microsoft, ce type de technologie permet au tiers de confiance (le prestataire qui va vérifier la validité des composants du système) d'accéder à distance au contenu de l'ordinateur, voire d'empêcher l'exécution de certaines opérations sur celui-ci.

Mémoire étendue

Ancien système d'extension de la mémoire permettant de dépasser la limite de 1Mio du microprocesseur 8086 de l'époque. Cette mémoire était accessible par pages de 64Kio.On ne l'utilise plus de nos jours en raison des capacités d'adressages étendues des processeurs récents ainsi qu'en raison de l'extrême lenteur des accès aléatoires dès que ceux-ci nécessitent un changement de page mémoire.

Systèmes d'exploitation multiples

Vanderpool/Silvervale: si un système d'exploitation de travail est infecté par un virus coriace, un autre de préférence sur une autre base comme Linux vers Mac OS ou Windows pourrait agir comme gardien et désinfecter le premier tout en ne laissant pas la possibilité au virus de se propager.

Anticipation des problèmes et gestion à distance

Particulièrement utile pour les serveurs

Le problème de l'échauffement 

Malgré l'usage de techniques de gravures de plus en plus fines, l'échauffement des microprocesseurs reste approximativement proportionnel au carré de leur tension à architecture donnée. Avec V la tension, f la fréquence, et K un coefficient d'ajustement, on peut calculer la puissance dissipée P:

Ce problème est lié à un autre, celui de la dissipation thermique et donc souvent des ventilateurs, sources de nuisances sonores. Le refroidissement liquide peut être utilisé.

L'utilisation d'une pâte thermique assure une meilleure conduction de la chaleur du processeur vers le radiateur.

Si l'échauffement ne pose pas de problème majeur pour des applications type ordinateur de bureau, il en pose pour toutes les applications portables. Il est techniquement facile d'alimenter et de refroidir un ordinateur fixe. Pour les applications portables, ce sont deux problèmes délicats. Le téléphone portable, l'ordinateur portable, l'appareil photo numérique, le PDA, le baladeur MP3 ont une batterie qu'il s'agit de ménager pour que l'appareil portable ait une meilleure autonomie.

Le microprocesseur multi-coeur

Un processeur Dual-Core(Intel Conroe)

Un processeur quad-core AMD Opteron

L'Intel Core 2 Duo E6600 est un processeur double coeur

Un microprocesseur multi-coeur(multi-core en anglais) est un processeur possédant plusieurs coeurs physiques qui travaillent en parallèle. Un coeur physique peut être comme un ensemble de circuits capable d'exécuter des programmes de façon autonome. Toutes les fonctionnalités nécessaire à l'exécution d'un programme sont présentes dans ces coeurs: Compteur ordinal, registres, unités de calcul, etc...

Histoire

Origines

Le terme "multi-coeur" est employé pour décrire un processeur composé d'au moins deux coeurs (ou unités de calcul) gravés au sein de la même puce.

On doit à IBM le premier processeur multi-coeur à avoir été commercialisé: il s'agit du POWER4, en 2001. En 2003, Sun lance l'UltraSPARC IV composé de 2 coeurs UltraSPARC III. En 2004, HP lance le PA-8800 composé de 2 coeurs PA-8700.

Les premiers exemplaires de processeurs multi-coeurs d'Intel et d'AMD sont arrivés sur le marché des ordinateurs personnels en 2005. Il s'agissait de coeurs homogènes,c'est-à-dire identiques. Le cas de coeurs différents et spécialisés dans des domaines bien précis (audio, affichage, calcul pur, etc...) a été exploité pour le processeur Cell conçu par IBM, Sony et Toshiba. Ce type d'architecture permet d'augmenter la fréquence d'horloge, et donc de réduire la quantité de chaleur dissipée par effet Joule (comme pour les systèmes multiprocessseur).

Les premières puces double coeur basées sur l'architecture X86 sont apparues en 2005 sur le marché des serveurs (Opterons d'AMD). Elles sont apparues parce qu'en pratique la course au GHz est devenue trop onéreuse et compliquée. La génération de processeurs de cette époque ne possédait qu'un seul coeur et avait une consommation qui pouvait dépasser largement les 100W (notamment sur les processeurs Intel Pentium 4). Elle devait donc faire face à de graves problèmes de refroidissement des circuits. La solution qui a semblé la plus évidente a été de privilégier non plus la fréquence, mais de multiplier la puissance grâce à une architecture parallèle, de façon à pouvoir augmenter le nombre d'opérations exécutées simultanément en un cycle d'horloge.

Evolution de la technologie

Depuis le lancement du premier ordinateur sur le marché, les demandes en capacités de calcul sont devenues de plus en plus importantes. Le multitraitement symétrique (SMP) a longtemps été utilisé pour améliorer les performances et l'efficacité informatiques en répartissant les charges sur plusieurs processeurs. Le SMP est particulièrement efficace dans les environnements multiprocesseurs où plusieurs tâches(processus) doivent être gérées simultanément.

Avec l'évolution des demandes de performances applicatives, les concepteurs de processeurs sont confrontés à un problème: L'augmentation des capacités informatiques est tributaire de la puissance, et le fait d'augmenter la puissance nécessite de gérer aussi les niveaux de dissipation. A cela s'ajoutent les demandes des industriels qui souhaitent des ordinateurs moins encombrants, à savoir plus de serveurs par baie, des ordinateurs portables plus fins et plus légers, et un encombrement réduit pour les systèmes de bureau. Le traitement multicoeur contribue à relever ces défis. Cette évolution technologique augmente les performances et la productivité dans les ordinateurs de plus petite taille capables d'exécuter simultanément plusieurs applications complexes et de réaliser davantage de tâches en moins de temps.

Processeurs multicoeurs existants

Il existe actuellement plusieurs architectures de processeurs multi-coeurs. Outre les modèles d'Intel et AMD déjà cités, Sun Microsystems a développé sa gamme Niagara et Niagara II, IBM a développé sa gamme de PowerPC et sa ligne CellBE, commercialisée par IBM sous forme de serveur lame, par Mercury sous forme de châssis renforcé. Le tout premier processeur double coeur pour smartphone lancé par Nvidia fut le Tegra 2 lancé en 2011.

L'industrie cherche dans le même temps à multiplier le nombre de coeurs présents sur un processeur, par exemple Intel dans son projet Tera-Scale.

Partage des caches

Tout processeur actuel contient des mémoires caches, qui rendent les accès à la mémoire plus rapides. Sur les processeurs multicoeurs, l'organisation de ces mémoires caches est adaptée à la présence de plusieurs coeurs. Deux grandes organisations de base sont utilisées: celle à base de caches dédiés à chaque coeur, et celle à base de caches partagés.

Dans le cas des caches dédiés, chaque coeur possède son propre cache, que lui seul peut utiliser. On trouve donc un cache pour chaque coeur.

Avec les caches partagés, la mémoire cache est partagée entre tous les processeurs, qui peuvent y accéder de façon concurrente.

Avantages et inconvénients des caches dédiés



Caches dédiés

L'organisation à base de caches dédiés a quelques avantages:

-un programme qui s'exécute sur un coeur ne va pas polluer le cache d'un autre processeur: deux programmes exécutés sur des coeurs différents n'interfèrent pas.

-Le temps d'accès à un cache dédié est souvent plus faible que celle d'un cache partagé. Il faut dire que les caches dédiés sont souvent d'une taille assez faible comparé à un gros cache partagé, conçu pour répondre aux besoins de plusieurs coeurs.

Avantages et inconvénients des caches partagés
 
Caches partagés

Mais l'organisation à base de caches partagés a aussi des avantages:

-Deux programmes peuvent se partager le cache dynamiquement: ils peuvent ainsi se répartir d'occupation du cache d'une manière bien plus souple que ce qui est permis avec un cache dédié.

-L'implémentation de mécanismes de cohérence des caches est facilitée.

-Elle évite de répliquer des données partagées entre plusieurs threads. Avec l'organisation en caches dédiés, une donnée utilisée par deux threads lancés sur deux coeurs différents doit être présente dans chacun des caches dédiés. Avec un cache partagée, la donnée est présente en une seule fois dans le cache partagé.

Toutefois, quelques inconvénients des caches partagés sont à signaler:

-Un cache partagé doit avoir une bande passante suffisante pour alimenter plusieurs coeurs, ce qui se fait souvent au détriment de sa latence.

-Un cache partagé doit pouvoir permettre à plusieurs coeurs d'accéder à des données différentes dans le cache simultanément, afin d'éviter de mettre un coeur en attente pendant un accès au cache. Conséquence: ces caches sont des mémoires multiports, ce qui a un impact sur leur consommation énergétique, leur latence, et leur débit binaire.

-Leur grande taille a un impact négatif sur leur latence et leur consommation énergétique.

-Plusieurs programmes peuvent se marcher sur les pieds dans leur répartition de la mémoire cache. Ce phénomène est rare, mais pas impossible.

Dans la réalité, compte tenu de ces contraintes, tous les caches du processeurs ne sont pas partagés. Ceux qui ont besoin d'une faible latence (cacheL1) sont des caches dédiés, tandis que les autres sont partagés (L2, L3).

Atouts

Avant l'apparition des processeurs multicoeurs, les constructeurs de processeurs augmentaient la puissance de leurs produits en élevant la fréquence de calcul de leurs processeurs monocoeurs. Mais cette méthode a fini par atteindre ses limites. En effet, l'augmentation de fréquence d'un processeur cause rapidement des problèmes de surchauffe. Pour lutter contre cette surchauffe, il faut passer à un refroidissement par eau délicat et onéreux, ou bien passer à des ventilations créatrices de nuisances sonores. Le besoin croissant en énergie était notamment problématique pour les ordinateurs portables.

Les processeurs monocoeurs les plus puissants utilisés dans les ordinateurs de grande distribution ont des fréquences ne dépassant en général pas les 3 ou 4GHz, car au-delà les problèmes cités plus haut deviennent trop contraignants. On a pu observer dans certains salons de technologie des processus de fréquence bien plus élevée, mais ils étaient équipés de refroidissement à l'azote liquide et autres.

C'est pour contourner cette limite que les constructeurs se sont tournés vers la fragmentation des puces. Il existait déjà des ordinateurs fonctionnant avec plusieurs processeurs distincts (par exemple, les supercalculateurs). L'idée ici est de reproduire ce parallélisme au sein d'un unique processeur: en bref, introduire plusieurs unités de calcul dans un même processeur. Le principe est simple: plutôt que d'avoir un processeur "simple" à fréquence élevée, on utilise par exemple deux coeurs, de fréquence moitié moindre. On obtient alors un processeur théoriquement de même puissance, mais de fréquence d'horloge bien plus basse, et de consommation électrique réduite. Le processeur ne rencontre pas les problèmes d'alimentation et de surchauffe de son homologue monocoeur.

En plus de ces avantages purement techniques, il s'avère que ces microprocesseurs sont également bien plus efficaces dans le traitement multitâche. Sur les systèmes mono-coeurs, le système d'exploitation change régulièrement le programme en cours d'exécution pour passer d'un programme à un autre. Ces changements sont très rapides, et ne sont donc pas visibles par l'utilisation, qui a l'impression que plusieurs programmes s'exécutent en même temps. Sur les systèmes multi-coeurs, si plusieurs applications sont exécutées simultanément sur l'ordinateur, celui-ci peut dès lors répartir ce travail entre les coeurs de processeurs, plutôt que d'effectuer les opérations en alternance sur un seul processeur.

Contraintes logicielles

Malheureusement, cette approche comporte quelques désavantages, puisque les programmes doivent être repensés pour pouvoir exploiter pleinement les caractéristiques de ces processeurs. En effet, les composants d'un processeur multicoeur ont une puissance individuelle inférieure à celle d'un processeur monocoeur classique, un logiciel non adapté au multicoeur et qui ne saura donc effectuer ses différents calculs qu'à l'aide d'un seul des coeurs du processeur sera conséquent exécuté à une vitesse moindre.

En 2006, très peu de logiciels gèrent le bi-coeurs, et globalement les logiciels ne sont pas conçus pour tirer le maximum de cette technologie (excepté dans le monde GNU/Linux où les applications sont portées en très grande majorité -près de 99,8%-sous plusieurs types d'architectures). Une fois effectuée une mise à niveau de tous les programmes vers la nouvelle architecture, les performances se détacheront nettement dans les applications gourmandes comme les jeux vidéo.

Ces mises à jour touchent également les systèmes d'exploitation, qui peuvent diviser par eux-mêmes les calculs effectués par des logiciels qu'ils exécutent. La technique multicoeur est alors utilisable même avec des logiciels non adaptés à ce type de traitement, cette utilisation étant cependant moins performante que si le logiciel indiquait comment doivent se diviser les calculs. De telles adaptations sont nécessaires à chaque augmentation du nombre de coeurs dans les processeurs. Ce n'est que lorsque celles-ci ont été effectuées que les nouveaux processeurs peuvent exprimer leur plein potentiel.

Le marché des télécommunications a été l'un des premiers à adopter les processeurs multi-coeurs, aussi bien pour la couche d'acheminement des données que pour la couche de commande. Depuis, ces MPU sont en train de remplacer rapidement les processeurs réseaux (NP) qui étaient basés sur des architectures privées à base de microcode et picocode. 6WIND a été la première société à fournir du logiciel réseau embarqué optimisé pour ces architectures multi-coeurs.

La programmation parallèle bénéficie également du passage à plusieurs coeurs. Des modèles de programmation comme OpenMP, MPI ou OpenHMPP peuvent être utilisés sur ces plates-formes multi-coeurs. D'autres efforts de recherche sont également menés, par exemple le système Codeplay Sieve, les langages Ateji PX, Chapel(en) de Cray, Fortress de Sun et X10 d'IBM.