Reduced instruction set computing

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
Ce modèle est-il pertinent ? Cliquez pour en voir d'autres.
Cet article n’est pas rédigé dans un style encyclopédique (janvier 2016).

Vous pouvez améliorer sa rédaction !

Ce modèle est-il pertinent ? Cliquez pour en voir d'autres.
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 » (modifier l'article, comment ajouter mes sources ?).

Page d'aide sur l'homonymie Pour les articles homonymes, voir RISC.
Un processeur HP RISC 7150.

Un processeur à jeu d'instructions réduit (en anglais Reduced instruction set computer ou RISC) est un type particulier d'architecture matérielle de processeurs qui se caractérise par un jeu d'instructions contenu, aisé à décoder, uniquement composé d'instructions simples, et dont les archétypes furent, dans les années 60 :

  • les hauts-de-gamme dérivés du Burroughs 5000 ou du CDC 6600.
  • pour les mini-ordinateurs,le PDP-8 : instructions de 12 bits, code opératoire sur 3 bits ; ou la série des HP 2100[1].

Cette stratégie était bien adaptée à la réalisation des microprocesseurs. À la fin des années 1980 et au début des années 1990 elle concurrençait des architectures traditionnelles plus lourdes CISC (complex instruction-set computer). En effet, les grandes différences de taille, de temps de décodage comme de temps d'exécution s'opposaient à des optimisations de type dit "pipe-line" [2]. Le Motorola 6800 n'en était pas moins dès le milieu des années 1970 une machine exécutant toutes ses instructions en un cycle, mais ne communiquait pas spécialement sur cette caractéristique)[3].

La sortie d'architectures hybrides comme le Pentium (CISC émulé par du RISC[4]) 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.

Principe[modifier | modifier le code]

À partir de 1970, la programmation symbolique s'étendant et les machines se diversifiant, certains programmes manifestèrent 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é [5] ou de la non-détection des situations favorables [6],[7] . Ainsi, seul un jeu réduit d'instructions était réellement utilisé dans beaucoup de programmes.

IBM avait conçu l'architecture de la série 360 sur un même jeu d'instructions sur tous ses mainframes, mais en câblant certaines, en microprogrammant d'autres, voire en émulant certaines par sous-programmes, selon la puissance demandée à tel modèle et son profil d'utilisation (majorité de scientifique, majorité de gestion, ou mélange des deux). Par exemple le 9370 était construit autour de la puce IBM 801, qui était également, utilisée en natif, le processeur de l'IBM 6150, alias PC/RT[réf. nécessaire].

Le 801 était un microprocesseur RISC. Cette architecture RISC fait le choix de limiter le jeu, mais surtout le format des instructions, à seulement quelques-uns, imposant à toutes une durée identique d'exécution. De cette manière, une nouvelle instruction est lançable à chaque cycle d'horloge : cela permet le « pipeline ». L'avantage de cette technique est que, désormais, 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 registre, à tel point que les compilateurs font parfois un travail plus efficace que les programmeurs chevronnés[8][réf. insuffisante].

Inconvénients[modifier | modifier le code]

Cela se paye au prix d'une certaine diminution de lisibilité du code gênante lorsque l'on programme en assembleur et surtout si on l'optimise : l'instruction MVC (MoVe Character) du Système 360 restait tout de même plus lisible que la séquence d'instructions faisant la même chose dans une machine RISC. Mais pour qui codait strcpy() en langage C, il n'y avait plus aucune différence. Et en temps d'exécution, le code C optimisé se montrait en général plus performant en vitesse pure grâce à des astuces d'usage de l'effet pipeline par le compilateur.

Le code RISC est généralement moins compact, puisque toutes les instructions sont de même taille, alors que les instructions les plus utilisées sont plus courtes dans un jeu d'instruction CISC. Cela entraîne également davantage d'accès à la mémoire, inconvénient que l'on peut limiter (sans trop de complexité si les instructions ne sont pas modifiables par les programmes) avec un cache d'instructions de grande taille, permis par la réduction de dimension de la circuiterie de calcul et de commande.

Avantages[modifier | modifier le code]

Du fait que chaque instruction était simple, le décodage et l'exécution par le processeur devaient être 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 étaient en général implémentées sous forme de micro-code dans le microprocesseur, chaque exécution de ce microcode 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 les divisions. Cela a 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 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 ou supérieures aux x86 de la même époque, n'avaient pas besoin de dissipateurs thermiques, tandis que l'on commençait à voir apparaitre des combinaisons de radiateurs et de ventilateurs sur ces derniers.

Caractéristiques architecturales des processeurs RISC[modifier | modifier le code]

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 :

  • 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 ont généralement 3 adresses : 2 registres servant d'opérandes et un registre de sortie ;
  • 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 être utilisée : on parle d'architecture load-store ou d'instructions register-register.

Des ajouts ont eu lieu ensuite pour améliorer leurs performances : des instructions plus petites 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.

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 transport triggered architectures ne fournissent que des instructions de transfert de valeur entre les registres et les unités de calcul.

Histoire[modifier | modifier le code]

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.

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 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, les processeurs APS3, ARM et MIPS présentent également une architecture RISC.

Performances comparées CISC/RISC[modifier | modifier le code]

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.

Positionnement[modifier | modifier le code]

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

Notes et références[modifier | modifier le code]

  1. jeu commun de 70 instructions ; développés en compatibilité ascendante de 1966 à 1996.
  2. apparues sur le CDC 6600
  3. François Anceau, Cours de programmation du 6800 avec J-Bug, école d'été de l'Afcet, 1975
  4. (en) Das Lyla B, The X86 Microprocessors: Architecture And Programming (8086 To Pentium), (lire en ligne).
  5. la gestion n'utilise pas l'arithmétique binaire, qui mettrait en échec les preuves comptables
  6. le même programme performant en assembleur ne l'était pas en Fortran. Comment détecter à la compilation la possibilité d'employer une instruction-machine d'évaluation de polynômes ?
  7. Jean-Jacques Girardot, à l'école des Mines de Saint-Etienne, mirent ainsi en évidence un dysfonctionnement matériel du Philips P1175 de leur école qui n'apparaissait que lors de certaines compilations de FORTRAN
  8. Brochure technique IBM, The 801 microprocessor, 1986

Voir aussi[modifier | modifier le code]

Articles connexes[modifier | modifier le code]

Architectures RISC[modifier | modifier le code]