Généralités

Au cœur de tout système informatique nous trouvons son “moteur”, le processeur (que l’on appelle microprocesseur s’il est physiquement rassemblé sur un seul composant électronique). Le processeur a quelques facultés de calcul de base ; il est généralement capable d’effectuer les quatre opérations arithmétiques sur des nombres entiers, parfois sur des nombres flottants.
Le processeur “sait” ce qu’il doit faire car il dispose d’instructions. Comme tout objet manipulé par l’informatique, l’instruction est une chaîne de bits (en général, 16 ou 32 bits) qui n’est toutefois pas considérée comme un nombre mais comme une phrase dans un langage. Toutes les actions que sait exécuter un processeur sont codées par une chaîne de bits - l’ensemble de ces actions avec leur code est ce que l’on appelle le jeu d’instructions du processeur. Pour exécuter une instruction, le processeur en lit donc le code, le “décode” et fait l’action demandée.

L’architecture des microprocesseurs

Un microprocesseur est physiquement constitué d’une plaque de silicium de quelques cm2, sur laquelle sont gravés des transistors. Ces derniers sont disposés de sorte à former des circuits logiques.
La communication avec l’extérieur se fait grâce à des fils métalliques reliant la plaquette de silicium aux contacts situés sur les bords du boîtier en matière plastique contenant le processeur.

Logiquement, on peut distinguer les éléments suivants :
- un bloc de séquencement, qui coordonne et synchronise les activités de tout le circuit;
- une unité arithmétique et logique (ALU), qui exécute les opérations dont est capable le processeur ;
- des registres, c’est à dire quelques dizaines ou quelques centaines d’octets de mémoire.

La mémoire

La suite d’instructions à exécuter - le programme - doit bien évidemment exister quelque part ; le deuxième élément important d’un ordinateur est la mémoire. Une cellule de mémoire peut être visualisée comme une “boîte” où peut être rangée une chaîne de bits de longueur donnée ; on a coutume, pour des raisons historiques, de considérer comme indivisible chaque groupe de 8 bits (l’octet) et de mesurer la taille d’une cellule en octets plutôt qu’en bits.

Tout processeur contient quelques cellules de mémoire internes (les registres), mais cette mémoire représente au maximum quelques centaines d’octets. La mémoire qui contient les programmes (et les données) est externe au processeur (localisée dans des circuits intégrés spécifiques) et reliée au processeur par une série de fils, appelée le BUS. Cette mémoire est généralement appelée mémoire centrale car, bien qu’externe au processeur, elle est au cœur de l’architecture de l’ordinateur. Pour fixer les idées, la taille de cette mémoire centrale va de quelques milliers à quelques milliards d’octets. Les octets présents dans la mémoire centrale sont numérotés, il est ainsi possible d’en désigner un en particulier par son numéro. En informatique, on parle souvent de l’adresse d’un objet (d’une information présente en mémoire) pour désigner le numéro de l’octet (ou du premier octet) qui code cet objet.

Les unités qui mesurent la taille d’une mémoire.

L’unité la plus usuelle est l’octet (8 bits), mais on trouve également le bit et le mot, dans ce dernier cas, on précise par exemple “mot de 32 bits”.
Les multiplicateurs les plus usités sont le K, M et G que l’on prononce à tort kilo, mega et giga. En effet, un “K” ne vaut pas 1000, mais 210, c’est à dire 1024. De même, un “M” vaut K2, soit 1048576, et un “G” vaut bien évidemment K3.
Si la documentation d’un constructeur précise donc “4 Mo de mémoire”, on lit :
“4 M octets”, c’est à dire 4194304 octets.

Architecture RISC

RISC est l’acronyme de “Reduced Instruction Set Computer”, c’est à dire “Ordinateur à jeu d’instructions réduit”. Les architectures RISC semblent être actuellement une voie importante vers la mise au point de processeurs de plus en plus rapides et pratiquement tous les constructeurs de processeurs ont “leur” RISC.
L’idée qui sous-tend toute architecture RISC est que quel que soit le processeur, certaines de ses instructions sont plus souvent utilisées que d’autres ; dans un code engendré par un compilateur, cette répartition est encore moins équitable, attendu que très rares sont les compilateurs capables de réellement exploiter le jeu d’instructions complet d’un processeur. Un processeur RISC est donc conçu de la manière suivante :

a) une étude statistique est effectuée sur les programmes les plus fréquemment utilisés par la “clientèle” du futur processeur, afin de déterminer les instructions les plus utilisées ;
b) un jeu d’instructions aussi réduit que possible est défini, contenant ces instructions “préférées”, tel que tout programme soit néanmoins réalisable ;
c) un processeur est construit qui ne connaît que ce jeu réduit, mais capable d’exécuter chaque instruction avec le maximum de vitesse.

De ce qui précède, il découle qu’un processeur RISC est moins “généraliste” qu’un processeur “traditionnel” (on parle en général de CISC, pour Complete Instruction Set Computer), ou tout au moins que le gain de vitesse que l’on peut observer dépendra du type d’application auquel on le destine : il y a ainsi des processeurs RISC plus particulièrement optimisés pour l’algorithmique graphique, ou pour le calcul numérique, ou encore le calcul symbolique.
La cadence d’exécution recherchée est d’une instruction par cycle d’horloge. Pour cela, les processeurs RISC mettent généralement enoeuvre les techniques suivantes :
• Homogénéité des opérations disponibles, de sorte que l’exécution elle-même prenne un temps inférieur à un cycle d’horloge - même si cela implique de sacrifier des opérations arithmétiques complexes.
• Pipe-line, généralement d’une longueur de 4 à 6 étapes; l’idée est qu’une instruction complète demande (par exemple) 4 cycles d’horloge, mais que, si le pipe-line est plein en permanence, une instruction sera effectivement achevée tous les cycles.
• Mémoire cache à outrance, afin d’éviter tout cycle passé à attendre le BUS - qui désamorcerait le pipe-line. En général, un processeur RISC possède trois caches gérés indépendamment, un pour les données, un pour les instructions et un pour la pile (qui stocke les variables locales, les adresses de retour de sous-programme etc.). La séparation de ces trois “mémoires” permet de plus un accès simultané aux données et aux instructions.
• Un grand nombre de registres, assorti d’un très faible nombre d’instructions capables d’aller lire ou écrire une donnée en mémoire centrale (le plus souvent, il n’en existe que deux, une du type “copier une valeur dans un registre” et une du type “copier un registre dans la mémoire centrale”). Non seulement cet état de fait encourage les programmeurs (et les compilateurs) à produire du code qui travaille essentiellement avec des données présentes dans les registres, mais encore limite-t-il les collisions sur le BUS.

Architecture superscalaire

Une architecture superscalaire est une autre manière - complémentaire à celle de l’architecture en pipe-line - d’utiliser simultanément plusieurs parties différentes du processeur. L’idée consiste ici à remarquer que, même dans une architecture pipe-line, on n’utilise pas simultanément les différentes unités de calcul spécialisées. Ainsi, par exemple, l’unité de calcul traitant les nombres entiers est physiquement distincte de celle traitant les nombres flottants. Un processeur superscalaire lit plusieurs instructions à l’avance et les trie selon l’unité spécialisée qui va les traiter ; ainsi, les unités spécialisées travaillent en général simultanément et le processeur peut, dans un cas favorable, traiter plus d’une instruction par cycle d’horloge.

Le PowerPC 601

C'est le premier-né de la famille des processeurs PowerPC. Dans la mesure où l’architecture de ce processeur RISC illustre bien les chapitres précédents nous allons le présenter de manière plus détaillée.
MPC 601 est un processeur RISC superscalaire organisé de sorte à pouvoir prendre place dans une architecture parallèle (ie à processeurs multiples).
Son architecture générale peut être découpée en deux grandes parties :
- un bloc gérant le BUS central, qui s’occupe en particulier de la gestion de la mémoire cache ;
- un bloc chargé d’effectuer les opérations, qui travaille essentiellement avec ses registres et dont la communication avec l’extérieur s’arrête au gestionnaire de la mémoire cache.

Un des points importants à souligner lorsque l’on parle de la gestion “externe” de la mémoire cache est la faculté du MPC 601 de maintenir la cohérence de son cache dans un environnement multiprocesseurs, sans intervention logiciel. Le gestionnaire applique le protocole “MESI” (acronyme de Modified, Exclusive, Shared, Invalid) : chaque cellule (une cellule représente 8 mots de 32 bits, soit 32 octets) de la mémoire cache peut être dans un des quatre états

• I : invalide, c’est à dire qu’elle ne “cache” aucune donnée réelle ;
• E : exclusive, c’est à dire qu’elle contient la copie d’une donnée de la mémoire centrale et il est certain qu’aucun autre processeur ne possède une copie de ces données dans son cache ;
• S : partagée (de l’anglais shared), c’est à dire qu’elle contient la copie d’une donnée de la mémoire centrale et il est possible qu’un autre processeur possède une copie de ces données dans son cache ;
• M : modifiée, c’est à dire que cette cellule contient la copie de données de la mémoire centrale mais une partie de ces données a été modifiée par le processeur - les données stockées dans la mémoire centrale ne sont donc pas à jour.

Le cœur du processeur est construit autour d’une file d’attente de 8 instructions dans laquelle trois unités spécialisées (unité de calcul flottant, unité de gestion de branchements, unité arithmétique et logique), montées selon un schéma d’architecture superscalaire, “piochent” à leur rythme les instructions qui les concernent. Chacune de ces trois unités est organisée en pipe-line.

Le PowerPC™ 601 est un microprocesseur superscalaire, capable de réaliser 3 instructions par cycle d’horloge dans trois unités indépendantes.

• Integer unit
• Floating-point Unit
• Branch processing Unit

Le PPC 601 est alimenté en 3,3 volts et possède trois modes de fonctionnement :
le mode nap (défaut), le mode doze (veille), et enfin le mode sleep (dormir).
Ces trois modes programmables reduisent à chaque fois la consommation du microprocesseur. Lorsqu’il n’est pas utilisé, le microprocesseur peut passer automatiquement dans le mode inférieur.

• 32 Ko de mémoire cache unique (Intructions et données).
• Bus de données 64 bits
• 10 Watts maximum à 80 Mhz
• 0,6 micron static CMOS technology
• taille 120 mm2
• 2,8 millions de transistors

Schéma simplifié représentant l’architecture de l’unité de calcul du MPC 601

Les trois unités opérantes représentées ci-dessus sont respectivement :

FPU : l’unité de calcul flottant, dont le pipe-line comporte 3 étages et 2 tampons ;
ALU : l’unité arithmétique et logique, dont le pipe-line comporte 2 étages et 2 tampons ;
BPU : l’unité de gestion des branchements, dont le pipe-line comporte 1 étage et 1 tampon.


Chaque unité opérante est formée d’un pipe-line et comporte quelques “étapes-tampon” qui permettent de mettre en attente une donnée sans bloquer le fonctionnement du pipe-line. L’unité arithmétique et logique consomme les instructions au fur et à mesure qu’elles arrivent dans le dernier étage de la file d’attente (ce dernier étage fait fonctionnellement partie de cette unité). Les deux autres unités “piochent” les instructions qui les concernent dans les quatre derniers étages de la file.
L’unité flottante est uniquement arithmétique - elle effectue les quatre opérations de base sur les nombres réels représentés sur 32 ou 64 bits.
L’unité de branchement mérite une mention spéciale. Sa tâche est de détecter les instructions qui modifient le déroulement du programme (instruction du type “aller à…”), les traiter, calculer la nouvelle adresse des instructions à exécuter et provoquer le rechargement de la file d’attente avec les instructions idoines (l’opération de branchement a ainsi un coût nul en temps). Cependant, il est impossible de traiter les instructions de type “si <condition> aller à …” avant que la condition ne soit évaluée par une des unités opérantes. Dans ce cas, l’unité de branchement fait une hypothèse sur le résultat de la condition et continue à exécuter comme si la réponse était connue - les instructions chargées dans la file sont donc des “instructions incertaines”. Une fois la condition évaluée, les instructions incertaines deviennent des instructions ordinaires (si l’hypothèse s’est révélée correcte) ou sont supprimées, ainsi que les résultats que ces instructions ont pu produire (le résultat d’une instruction incertaine n’est pas écrit en registre avant que l’incertitude soit résolue).

Le PowerPC 603

A la différence du 601, le processeur 603 a des mémoires cache “données” et “programme” séparées. Ils ne possèdent par conséquent pas de file d’attente d’instructions à exécuter, puisque la lecture des instructions peut se faire à tout moment, même lorsque par ailleurs une opérande doit être lue en mémoire.

Les schémas de fonctionnement de ces deux processeurs sont très semblables :
• les instructions sont lues depuis le cache “programme” par paquets de n (n = 2 pour le 603, n = 4 pour le 604) instructions chaque cycle d’horloge ;
• le décodage des instructions est fait immédiatement - n instructions sont décodées chaque cycle d’horloge ;
• les instructions de branchement - qui modifient le déroulement du programme - sont détectées immédiatement et acheminées vers l’unité de gestion de branchements.
• les valeurs des opérandes des instructions qui en ont besoin sont lues depuis les registres dès la phase de décodage ; ainsi, une instruction “calculer R3 = R1 + R2” arrive dans le répartiteur sous la forme, par exemple, de “calculer R3 = 56 + 247”. Si, dans cet exemple, la valeur de R2 devait être modifiée par une instruction antérieure mais non encore terminée, l’instruction arriverait sous la forme “calculer R3 = 56 + R2”.
• les instructions sont stockées dans un module répartiteur. Celui-ci distribue les instructions à traiter aux unités adéquates dès que celles-ci sont prêtes à les recevoir, à la cadence de n instructions distribuées par cycle d’horloge.
• dans le répartiteur, chaque instruction se voit allouer une place dans une file d’attente. Cette file d’attente sera utilisée à la fin de l’exécution pour que la sortie des résultats soit faite dans l’ordre.
• trois unités spécialisées dans le cas de MPC 603, cinq unités spécialisées dans le cas de MPC 604 traitent les instructions ; ces unités ont chacune leur structure de pipe-line interne.
• les résultats des évaluations sont stockés dans des registres temporaires, en attendant la remise dans l’ordre initial des instructions. Les instructions en attente d’opérandes (l’instruction “calculer R3 = 56 + R2” de notre exemple précédent) disposent des valeurs qu’elles attendent dès que celles-ci sont calculées et stockées dans un registre temporaire, sans avoir à attendre qu’elles soient écrites dans le registre définitif.
• enfin, les valeurs calculées sont remises dans l’ordre dans la file d’attente et inscrites dans les registres idoines dans l’ordre théorique d’exécution des instructions. A chaque cycle d’horloge, n résultats peuvent ainsi être consommés.

Diagramme du Power PC 603

PowerPC™ 603 : caractéristiques

Le microprocesseur PowerPC™ 603 est un microprocesseur basse consommation de technologie RISC. Il est recommandé pour les machines d’entrée de gamme et/ou basse consommation.
Il est utilisé principalement dans la gamme Performa et PowerBook

Le PowerPC™ est un microprocesseur superscalaire, capable de réaliser 3 instructions par cycle d’horloge dans cinq unités indépendantes.

• Integer unit
• Floating-point Unit
• Branch processing Unit
• Load/Store Unit
• System Register Unit

Le PPC 603 est alimenté en 3,3 volts et possède trois modes de fonctionnement:
le mode nap (défaut), le mode doze (veille), et enfin le mode sleep (dormir).
Ces trois mode programmable reduisent à chaque fois la consommation du microprocesseur. Lorsqu’il n’est pas utilisé le microprocesseur peut passer automatiquement dans le mode inférieur.

Le microprocesseur PPC 603 possède 8 Ko de cache Intructions et 8 Ko de cache données.
Il possède une MMU (Memory Management Unit) séparée pour les instructions et les données. La MMU supporte 4 Peta-Octets (252) de mémoire virtuelle et 4 Giga-Octets de mémoire physique (232).

Le PowerPC™ 603 a un bus de données pouvant fonctionner en 2 modes différents : 32 bits ou 64 bits et un bus d’adresse sur 32 bits.

• 3,3 Volts
• 0,5 micron static CMOS technology
• taille 83 mm2
• 1,6 million de transistors

• 8 Ko de cache Instructions et 8 Ko de cache données
• Superscalaire - 3 instructions par cycle d’horloge
• un composant de gestion de la consommation
• 32/64 bits data mode

PowerPC™ 603e

La différence entre en microprocesseur PPC 603 et PPC 603e se situe au niveau de la mémoire cache.
Le PPC 603e possède 16 Ko de cache Instructions et 16 Ko de cache données.

• 2,5 volts ou 3,3 volts
• 0,35 micron ou 0,5 micron static CMOS technology
• 81 mm2 ou 98mm2
• 2,6 millions de transistors
• 16 Ko de cache Instructions et 16 Ko de cache données
• Superscalaire - 3 instructions par cycle d’horloge
• un composant de gestion de la consommation
• 32/64 bits data mode




Le PowerPC™ 604e

Le microprocesseur PowerPC™ 604e est un microprocesseur 32 bits de technologie RISC. Il est recommandé pour les machines ayant de hautes performances et/ou un fonctionnement en multiprocesseur. Le bus de PowerPC™ 604e est compatible avec la famille des microprocesseurs PPC 603 et PPC 601

Le PowerPC™ 604e est un microprocesseur superscalaire, capable de réaliser 4 instructions par cycle d’horloge dans six unitées indépendantes.

• Two single-cycle integer units
• One multi-cycle integer unit
• Branch processing Unit
• Load/Store Unit
• Floating point unit
• Condition register unit

Le microprocesseur PPC 604e possède 32 Ko de cache Intructions et 32 Ko de cache données.
Il possède une MMU (Memory Management Unit) séparée pour les instructions et les données. La MMU supporte 4 Peta-Octets (252) de mémoire virtuelle et 4 Giga-Octets (232) de mémoire physique.

Diagramme du PowerPC™ 604e

• 2,5 Volts
• 0,35 micron static CMOS technology
• taille 148 mm2
• 5,1 millions de transistors
• 32 Ko de cache Instructions et 32 Ko de cache données
• Superscalaire - 4 instructions par cycle d’horloge
• 3 registres additionnels pour augmenter les performances de la gestion d’écran
• Consommation à 200 Mhz : 12 Watts