Processeur à jeu d'instructions réduit

Pour les articles homonymes, voir RISC.

Cet article ne cite pas suffisamment ses sources (mai 2016).

Si vous disposez d'ouvrages ou d'articles de référence ou si vous connaissez des sites web de qualité traitant du thème abordé ici, merci de compléter l'article en donnant les références utiles à sa vérifiabilité et en les liant à la section « Notes et références ».

En pratique : Quelles sources sont attendues ? Comment ajouter mes sources ?

Un processeur à jeu d'instructions réduit (en anglais RISC pour reduced instruction set computer) est un type d'architecture de processeur qui se caractérise par un jeu d'instructions visant la rapidité d'exécution grâce à la facilité de décodage et d'exécution en pipeline des instructions machine.

À la fin des années 1980 et au début des années 1990, cette stratégie permet aux microprocesseurs RISC d'obtenir de meilleures performances que les architectures anciennes, de type CISC (de l'anglais complex instruction set computer). En effet, les grandes différences de taille, de temps de décodage et de temps d'exécution des instructions s'opposaient à des optimisations de type dit « pipeline »^[a].

La sortie d'architectures hybrides comme le Pentium Pro (CISC émulé par du RISC^[1]) a mis fin, par disparition de repères, à cette guerre qui était devenue bien plus marketing que technique vers 1990, les techniques ayant évolué de part et d'autre et chacune comparant ses procédés à ceux de l'autre six ans plus tôt.^{[réf. nécessaire]}

Principe

À partir de 1970, la programmation symbolique s'est étendue et les machines se sont diversifiées. Certains programmes requièrent des temps d'exécution difficilement explicables. L'analyse des séquences de codes montre qu'une grande majorité des instructions disponibles sont peu utilisées, du fait de la rareté ou de la non détection des situations favorables^[b],[c]. Ainsi, seul un jeu réduit d'instructions est réellement utilisé dans beaucoup de programmes.

L'architecture RISC fait le choix de limiter le nombre et surtout le format des instructions, imposant à toutes une durée identique d'exécution. De cette manière, il est possible de lancer une nouvelle instruction à chaque cycle d'horloge et donc d'utiliser la technique du « pipeline ». L'avantage de cette technique est que le processeur se comporte comme s'il y avait une instruction exécutée par cycle d'horloge. De plus, la division de chaque instruction en plusieurs étapes autorise une fréquence d'horloge plus grande puisque la profondeur combinatoire entre deux registres est diminuée. Ces deux caractéristiques ont pour conséquence une division du temps d'exécution pour toutes les instructions de base. Elles permettent également de mettre dans la puce un plus grand cache et davantage de registres, à tel point que les compilateurs font parfois un travail plus efficace que les programmeurs chevronnés^{[2][source insuffisante]}.

Inconvénients

Cette section ne cite pas suffisamment ses sources (août 2019). 

Pour l'améliorer, ajoutez des références de qualité et vérifiables (comment faire ?) ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.

Le code RISC est généralement moins compact, puisque toutes les instructions ont la même taille, alors que les instructions les plus utilisées sont plus courtes dans un jeu d'instructions CISC. Cela entraîne davantage d'accès à la mémoire vive. En outre, les jeux d'instructions RISC ont visé dès le début à atteindre un taux d'exécution d'une instruction par cycle, ce qui ne laisse pas le temps d'accéder aux données. Ces inconvénients sont palliés par une mémoire cache en architecture de Harvard séparant instructions et données.

Avantages

Cette section ne cite pas suffisamment ses sources (août 2019). 

Pour l'améliorer, ajoutez des références de qualité et vérifiables (comment faire ?) ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.

Puisque l'instruction est simple, le décodage et l'exécution par le processeur sont très rapides, idéalement en un seul cycle, voire deux instructions par cycle, ce qui n'était pas le cas des instructions CISC. Sur les processeurs CISC, les instructions sont en général implémentées sous forme de microcode dans le microprocesseur, l'exécution de chaque instruction du microcode prenant un cycle. Pour un Motorola 68000 par exemple, les instructions les plus rapides prennent quatre cycles et les plus longues jusqu'à 160 cycles pour calculer les divisions. Le changement s'opère à l'arrivée du Motorola 68030, pour lequel certaines instructions peuvent ne prendre qu'un cycle.

Au contraire, les processeurs RISC qui sont utilisés sur des calculateurs plus puissants se sont vu ajouter des instructions du type multiplieur-accumulateur, instruction la plus utilisée dans le calcul vectoriel et matriciel. Ces instructions câblées en dur ne prennent qu'un seul cycle pour multiplier deux registres, y ajouter un autre registre et sauvegarder le résultat soit dans l'un de ces registres, soit dans un autre. C'est le cas par exemple dans l'architecture PowerPC, qui a équipé les Macintosh de 1994 à 2006.

Un autre avantage du RISC sur le CISC concerne la perte d'énergie par dissipation thermique. Alors que les microprocesseurs x86 peuvent être équipés d'une combinaison de radiateurs et de ventilateurs, les premiers modèles de PowerPC ayant des capacités de calcul similaires, voire supérieures, n'ont pas besoin de dissipateurs thermiques.

Caractéristiques architecturales des processeurs RISC

Les processeurs RISC font reposer l'optimisation du code sur le compilateur, tandis que les instructions sont faciles à décoder pour le processeur. Pour cela, à l'origine :

• Ces processeurs disposent de beaucoup de registres « généraux » (au moins 16, généralement 32), tous équivalents, pour faciliter leur allocation par le compilateur ;
• Les instructions sont de taille fixe, souvent 32 bits ;
• Les instructions arithmétiques sont généralement à trois opérandes : deux registres servant de source et un registre de destination ;
• Les accès à la mémoire font l'objet d'instructions spécifiques, et une valeur doit d'abord être chargée dans un registre pour pouvoir être utilisée : architecture load-store (en) ou instructions register-register.

Des ajouts ont ensuite lieu pour améliorer leurs performances : des instructions plus petites, comme avec les extensions Thumb, puis Thumb-2 de l'architecture ARM ou des méthodes de compression du code sont introduites et les fenêtres de registres accélèrent les appels de fonction sur certaines architectures. Les architectures RISC actuelles peuvent aussi utiliser des instructions vectorielles et une unité de calcul en virgule flottante.

L'unité de calcul des processeurs RISC, du fait de sa simplicité, est souvent plus petite. À taille de puce égale, on peut donc lui adjoindre un cache plus grand, et le plus souvent deux caches : l'un pour les données et l'autre pour les instructions (qu'il n'est jamais besoin de réécrire dans la mémoire principale, d'où une plus grande simplicité des circuits).

D'autres types d'architectures cherchent à réduire la complexité du jeu d'instructions, mais se différencient des architectures RISC par les moyens utilisés : les opérandes sont les éléments du haut d'une pile et non des registres pour les processeurs à piles, tandis que les transport triggered architectures ne fournissent que des instructions de transfert de valeur entre les registres et les unités de calcul ^{[réf. nécessaire]}.

Histoire

Un processeur tel que le Transputer d'Inmos (plus tard STMicroelectronics) adopte la solution de remplacer les registres (dont la désignation consomme des bits dans les instructions) par une pile. D'autres machines RISC, au contraire, comme le RS/6000 d'IBM, multiplient les registres à un degré tel qu'on ne peut plus les programmer efficacement en assembleur, la mémoire du programmeur faisant toujours moins bien que les algorithmes d'optimisation des compilateurs de langage C.

L'IBM 801 est un microprocesseur RISC. MIPS Technologies est également la première société à produire des processeurs 64 bits RISC (principalement utilisé sur les stations Silicon Graphics).

Les processeurs de la famille PowerPC, dérivés du RS/6000 et utilisés entre autres sur les Macintosh (jusqu'en 2006), les consoles GameCube, Wii et Wii U de Nintendo ainsi que la Xbox 360 de Microsoft sont à architecture RISC, de même que les processeurs SPARC utilisés entre autres par Sun Microsystems pour leurs serveurs et stations de travail.

Les micro-ordinateurs de type compatible PC sont animés jusqu'au Pentium par des microprocesseurs de type CISC. Depuis la génération Pentium Pro, l'architecture CISC est émulée dans les puces d'architecture IA-32 par la microprogrammation d'un processeur RISC sous-jacent.

Dans le monde de l'électronique embarquée et de l'informatique mobile (tablettes, smartphones et agendas électroniques), les processeurs ARM et MIPS présentent également une architecture RISC.

L'architecture RISC-V est une architecture ouverte sous licence libre, utilisant un jeu d'instruction RISC, d'implémentation 32, 64 et 128 bits, et utilisé à la fois dans des microprocesseurs et des microcontrôleurs, et est implémentée dans des versions allant de l'internet des objets, au supercalculateur avec le European Processor Initiative.

Performances comparées CISC/RISC

On connaît un cas du même logiciel tournant à la fois sur une machine RISC microprogrammée émulant un CISC et en natif : il s'agit d'AIX tournant sur un IBM 9370 (puce IBM 860 microprogrammant une architecture 370) et, à la même époque, sur le PC/RT (6150) qui utilise cette même puce 860 en natif : l'écart de performances en calcul brut est alors d'un facteur deux en faveur du PC/RT ^{[réf. nécessaire]}.

Aujourd'hui^[Quand ?], les performances des deux familles de processeurs sont sensiblement comparables.

Notes et références

Voir aussi