Processeur à jeu d'instructions réduit
Un processeur à jeu d'instructions réduit (en anglais RISC pour ) 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  (de l'anglais ). 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 ».

La sortie d'architectures hybrides comme le Pentium Pro (CISC émulé par du RISC) a mis fin, par disparition de repères, à cette guerre qui était

Principe 
À partir de 1970, la programmation symbolique s'était étendue et les machines s'étaient diversifiées. Certains programmes ont alors manifesté des temps d'exécution peu explicables. L'analyse des séquences de codes montra qu'une grande majorité des instructions disponibles étaient peu utilisées, du fait de la rareté ou de la non-détection des situations favorables. Ainsi, seul un jeu réduit d'instructions était réellement utilisé dans beaucoup de programmes.

L'architecture RISC avait fait le choix de limiter le jeu d'instructions, mais surtout leur format, à seulement quelques-unes, imposant à toutes une durée identique d'exécution. De cette manière, il était possible de lancer une nouvelle instruction à chaque cycle d'horloge : cela permettait 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 .

Inconvénients 

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'instruction 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 

Du fait que chaque instruction est simple, le décodage et l'exécution par le processeur est très rapide, 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 étaient en général implémentées sous forme de micro-code dans le microprocesseur, chaque exécution de ce micro-code prenait un cycle. Pour un Motorola 68000 par exemple, les instructions les plus rapides prenaient 4 cycles et les plus longues jusqu'à 160 cycles pour calculer les divisions. Cela avait changé avec les Motorola 68030, dont certaines instructions pouvaient ne prendre qu'un cycle.

Au contraire, les processeurs RISC qui étaient utilisés sur des calculateurs plus puissants se sont vu ajouter des instructions du type MULADD (multiplication + addition), instruction la plus utilisée dans le calcul vectoriel et matriciel. Ces instructions câblées en dur ne prenaient qu'un seul cycle pour multiplier 2 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, ou la BeBox, qui fut en 1995 le premier micro-ordinateur à double processeur.

Un autre avantage du RISC sur le CISC concerne la perte d'énergie par dissipation thermique. Les premiers modèles de PowerPC ayant des capacités de calcul similaires, voire supérieures, aux microprocesseurs x86 de la même époque, n'avaient pas besoin de dissipateurs thermiques, alors qu'on commençait à voir apparaître des combinaisons de radiateurs et de ventilateurs sur les x86.

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 disposaient 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 étaient de taille fixe, souvent 32 bits ;
 Les instructions arithmétiques avaient généralement 3 opérandes : 2 registres servant de source et un registre de destination ;
 Les accès à la mémoire faisaient l'objet d'instructions spécifiques, et une valeur devaient d'abord être chargée dans un registre pour pouvoir être utilisée : on parlait d'architecture  ou d'instructions .

Des ajouts ont eu lieu ensuite 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 ont été 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 ont cherché à 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  ne fournissent que des instructions de transfert de valeur entre les registres et les unités de calcul.

Histoire 
Un processeur tel que le Transputer d'Inmos (plus tard STMicroelectronics) adopta 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, multiplièrent les registres à un degré tel qu'on ne pouvait 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 était un microprocesseur RISC. Les processeurs MIPS R3000 furent les premiers du marché à implémenter l'architecture RISC, suivis par l'Alpha de Digital. MIPS Technologies fut é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 étaient animés jusqu'à la génération 486 par des microprocesseurs de type CISC (NEC, STMicroelectronics, AMD, Intel…). Depuis la génération 586, 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 APS3, 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é 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 utilisait cette même puce 860 en natif : l'écart de performances en calcul brut était alors d'un facteur 2 en faveur du PC/RT.

Aujourd'hui, les performances des deux familles de processeurs sont sensiblement comparables.

Notes et références

Notes

Références

Voir aussi

Articles connexes

Général 
 CISC

Architectures RISC 
 ARM, MIPS, SPARC, PowerPC et PA-RISC.

Microprocesseur