Ordinateur à jeu d'instructions réduit

En électronique et en informatique , un ordinateur à jeu d'instructions réduit ( RISC ) est une architecture informatique conçue pour simplifier les instructions individuelles données à l'ordinateur pour accomplir des tâches. Par rapport aux instructions données à un ordinateur à jeu d'instructions complexe (CISC), un ordinateur RISC peut nécessiter plus d'instructions (plus de code) pour accomplir une tâche car les instructions individuelles sont écrites dans un code plus simple. L'objectif est de compenser la nécessité de traiter plus d'instructions en augmentant la vitesse de chaque instruction, notamment en implémentant un pipeline d'instructions , qui peut être plus simple à réaliser avec des instructions plus simples.

Le concept opérationnel clé de l'ordinateur RISC est que chaque instruction n'exécute qu'une seule fonction (par exemple, copier une valeur de la mémoire vers un registre). L'ordinateur RISC dispose généralement de nombreux registres à usage général à grande vitesse (16 ou 32) avec une architecture de chargement-stockage dans laquelle le code des instructions registre-registre (pour effectuer des calculs et des tests) est séparé des instructions qui accèdent à la mémoire principale de l'ordinateur. La conception du processeur permet aux ordinateurs RISC de disposer de quelques modes d'adressage simples et de temps d'instruction prévisibles qui simplifient la conception du système dans son ensemble.

Les développements conceptuels de l'architecture informatique RISC ont commencé avec le projet IBM 801 à la fin des années 1970, mais ils n'ont pas été immédiatement mis en œuvre. Les concepteurs californiens ont repris les concepts du 801 dans deux projets phares, Stanford MIPS et Berkeley RISC . Ceux-ci ont été commercialisés dans les années 1980 sous les noms de systèmes MIPS et SPARC . IBM a finalement produit des conceptions RISC basées sur des travaux ultérieurs sur le concept 801, l' architecture IBM POWER , PowerPC et Power ISA . Au fur et à mesure que les projets ont mûri, de nombreuses conceptions similaires, produites au milieu ou à la fin des années 1980 et au début des années 1990, telles que ARM , PA-RISC et Alpha , ont créé des unités centrales de traitement qui ont augmenté l'utilité commerciale de la station de travail Unix et des processeurs intégrés dans l' imprimante laser , le routeur et des produits similaires.

Sur le marché des mini-ordinateurs , des sociétés telles que Celerity Computing , Pyramid Technology et Ridge Computers ont commencé à proposer des systèmes conçus selon les principes RISC ou de type RISC au début des années 1980. Peu de ces conceptions ont commencé par utiliser des microprocesseurs RISC .

Les différents types de processeurs RISC comprennent le processeur ARC , le DEC Alpha, l' AMD Am29000 , l'architecture ARM, l' Atmel AVR , le Blackfin , l'Intel i860 , l'Intel i960 , le LoongArch , le Motorola 88000 , l'architecture MIPS, le PA-RISC, le Power ISA, le RISC-V , le SuperH et le SPARC. Les processeurs RISC sont utilisés dans les supercalculateurs , tels que le Fugaku .

Un certain nombre de systèmes, remontant aux années 1960, ont été crédités comme étant la première architecture RISC, en partie en raison de leur utilisation de l' approche de chargement-stockage . Le terme RISC a été inventé par David Patterson du projet RISC de Berkeley , bien que des concepts quelque peu similaires soient déjà apparus auparavant.

Le CDC 6600 conçu par Seymour Cray en 1964 utilisait une architecture de chargement-stockage avec seulement deux modes d'adressage (registre+registre et registre+constante immédiate) et 74 codes d'opération, le cycle d'horloge de base étant 10 fois plus rapide que le temps d'accès à la mémoire. En partie en raison de l'architecture de chargement-stockage optimisée du CDC 6600, Jack Dongarra dit qu'il peut être considéré comme un précurseur des systèmes RISC modernes, bien qu'un certain nombre d'autres obstacles techniques aient dû être surmontés pour le développement d'un système RISC moderne.

Michael J. Flynn considère que le premier système RISC est le modèle IBM 801 , commencé en 1975 par John Cocke et achevé en 1980. Le 801 est né d'un effort visant à construire un processeur 24 bits à grande vitesse à utiliser comme base pour un commutateur téléphonique numérique . Pour atteindre leur objectif de commutation d'un million d'appels par heure (300 par seconde), ils ont calculé que le processeur nécessitait des performances de l'ordre de 12 millions d'instructions par seconde (MIPS), par rapport à leur ordinateur central le plus rapide de l'époque, le 370/168 , qui fonctionnait à 3,5 MIPS.

La conception était basée sur une étude de la vaste collection de statistiques d'IBM recueillies auprès de ses clients. Cela a démontré que le code dans des paramètres de haute performance utilisait largement les registres du processeur et qu'ils en manquaient souvent. Cela suggérait que des registres supplémentaires amélioreraient les performances. De plus, ils ont remarqué que les compilateurs ignoraient généralement la grande majorité des instructions disponibles, en particulier les modes d'adressage orthogonaux. Au lieu de cela, ils sélectionnaient la version la plus rapide de n'importe quelle instruction donnée et construisaient ensuite de petites routines en l'utilisant. Cela suggérait que la majorité des instructions pouvaient être supprimées sans affecter le code résultant. Ces deux conclusions fonctionnaient de concert ; la suppression d'instructions permettrait aux opcodes d'instruction d'être plus courts, libérant ainsi des bits dans le mot d'instruction qui pourraient ensuite être utilisés pour sélectionner parmi un ensemble plus large de registres.

Le programme de commutation téléphonique a été annulé en 1975, mais à ce moment-là, l'équipe avait démontré que la même conception offrirait des gains de performances significatifs en exécutant à peu près n'importe quel code. Dans des simulations, ils ont montré qu'un compilateur réglé pour utiliser des registres autant que possible exécuterait du code environ trois fois plus vite que les conceptions traditionnelles. De manière assez surprenante, le même code s'exécuterait environ 50 % plus rapidement, même sur des machines existantes, en raison de l'utilisation améliorée des registres. Dans la pratique, leur compilateur expérimental PL/8, une version légèrement réduite de PL/I , produisait systématiquement du code qui s'exécutait beaucoup plus rapidement sur leurs mainframes existants.

Une version 32 bits du 801 a finalement été produite sous forme de puce unique sous le nom d' IBM ROMP en 1981, qui signifie « Research OPD [Office Products Division] Micro Processor ». Ce processeur a été conçu pour les tâches « mini » et a été utilisé dans les interfaces périphériques et les contrôleurs de canal sur les ordinateurs IBM ultérieurs. Il a également été utilisé comme processeur dans l' IBM RT PC en 1986, qui s'est avéré être un échec commercial. Bien que le 801 n'ait pas été largement utilisé dans sa forme originale, il a inspiré de nombreux projets de recherche, y compris ceux d'IBM qui ont finalement conduit à l' architecture IBM POWER .

À la fin des années 1970, le 801 était devenu bien connu dans l'industrie. Cela a coïncidé avec de nouvelles techniques de fabrication qui ont permis la commercialisation de puces plus complexes. Le Zilog Z80 de 1976 avait 8 000 transistors, tandis que le Motorola 68000 (68k) de 1979 en avait 68 000. Ces conceptions plus récentes utilisaient généralement leur nouvelle complexité pour étendre le jeu d'instructions afin de le rendre plus orthogonal. La plupart, comme le 68k, utilisaient un microcode pour ce faire, lisant les instructions et les réimplémentant sous forme d'une séquence d'instructions internes plus simples. Dans le 68k, un tiers complet des transistors était utilisé pour ce microcodage. [

En 1979, David Patterson a été envoyé en congé sabbatique de l' Université de Californie à Berkeley pour aider l'équipe de DEC de la côte ouest à améliorer le microcode VAX. Patterson a été frappé par la complexité du processus de codage et a conclu qu'il était intenable. Il a d'abord écrit un article sur les moyens d'améliorer le microcode, mais a ensuite changé d'avis et a décidé que le microcode lui-même était le problème. Avec le financement du programme DARPA VLSI , Patterson a lancé l' effort RISC de Berkeley . Le programme, pratiquement inconnu aujourd'hui, a conduit à un grand nombre d'avancées dans la conception des puces, la fabrication et même l'infographie. En examinant une variété de programmes de leur variante BSD Unix , l'équipe de Berkeley a découvert, comme l'avait fait IBM, que la plupart des programmes n'utilisaient pas la grande variété d'instructions du 68k.

Les premiers travaux de Patterson ont mis en évidence un problème important avec l'approche traditionnelle « plus c'est mieux » ; même les instructions essentielles aux performances globales étaient retardées par leur passage dans le microcode. Si le microcode était supprimé, les programmes s'exécuteraient plus rapidement. Et comme le microcode prenait finalement une instruction complexe et la décomposait en étapes, il n'y avait aucune raison pour que le compilateur ne puisse pas le faire à la place. Ces études suggéraient que, même sans autres changements, on pourrait fabriquer une puce avec 1/3 de transistors en moins qui fonctionnerait plus rapidement. Dans le document RISC-I original, ils notaient :

Le fait de sauter ce niveau supplémentaire d’interprétation semble améliorer les performances tout en réduisant la taille de la puce.

Il a également été découvert que, sur les implémentations microcodées de certaines architectures, les opérations complexes avaient tendance à être plus lentes qu'une séquence d'opérations plus simples effectuant la même chose. Cela était en partie dû au fait que de nombreuses conceptions étaient bâclées, avec peu de temps pour optimiser ou régler chaque instruction ; seules celles utilisées le plus souvent étaient optimisées, et une séquence de ces instructions pouvait être plus rapide qu'une instruction moins réglée effectuant une opération équivalente à cette séquence. Un exemple tristement célèbre était l' instruction du VAXINDEX .

Les travaux de Berkeley ont également permis de mettre en évidence un certain nombre de points supplémentaires. Parmi ceux-ci, le fait que les programmes passaient beaucoup de temps à exécuter des appels et des retours de sous-programmes , et il semblait qu'il était possible d'améliorer les performances globales en accélérant ces appels. Cela a conduit les concepteurs de Berkeley à sélectionner une méthode connue sous le nom de fenêtres de registres , qui peut améliorer considérablement les performances des sous-programmes, bien qu'au prix d'une certaine complexité. Ils ont également remarqué que la majorité des instructions mathématiques étaient des tâches simples ; seulement un tiers d' entre elles effectuaient réellement une opération comme l'addition ou la soustraction. Mais lorsque ces opérations se produisaient, elles avaient tendance à être lentes. Cela a conduit à mettre beaucoup plus l'accent sur l'unité de données arithmétiques sous-jacente, contrairement aux conceptions précédentes où la majorité de la puce était dédiée au contrôle et au microcode.

Le RISC de Berkeley qui en résulta était basé sur le gain de performance grâce à l'utilisation du pipelining et à l'utilisation agressive du fenêtrage des registres. Dans un processeur traditionnel, on a un petit nombre de registres, et un programme peut utiliser n'importe quel registre à tout moment. Dans un processeur avec des fenêtres de registres, il y a un très grand nombre de registres, par exemple 128, mais les programmes ne peuvent en utiliser qu'un petit nombre, par exemple huit, à tout moment. Un programme qui se limite à huit registres par procédure peut effectuer des appels de procédure très rapides : l'appel déplace simplement la fenêtre « vers le bas » de huit, jusqu'à l'ensemble de huit registres utilisés par cette procédure, et le retour déplace la fenêtre vers l'arrière. Le projet RISC de Berkeley a livré le processeur RISC-I en 1982. Composé de seulement 44 420 transistors (comparé à une moyenne d'environ 100 000 dans les conceptions CISC plus récentes de l'époque), le RISC-I n'avait que 32 instructions, et pourtant surpassait complètement toute autre conception à puce unique, avec des performances estimées supérieures à celles du VAX. Ils ont suivi cela avec le RISC-II de 40 760 transistors et 39 instructions en 1983, qui fonctionnait plus de trois fois plus vite que le RISC-I.

Alors que le projet RISC commençait à être connu dans la Silicon Valley , un projet similaire débuta à l'Université de Stanford en 1981. Ce projet MIPS est né d'un cours de troisième cycle de John L. Hennessy , a produit un système fonctionnel en 1983 et pouvait exécuter des programmes simples en 1984. L'approche MIPS mettait l'accent sur un cycle d'horloge agressif et l'utilisation du pipeline, garantissant qu'il pouvait être exécuté aussi « complet » que possible. Le système MIPS a été suivi par le MIPS-X et en 1984, Hennessy et ses collègues ont formé MIPS Computer Systems pour produire la conception commercialement. L'entreprise a abouti à une nouvelle architecture qui a également été appelée MIPS et au microprocesseur R2000 en 1985.

La philosophie globale du concept RISC a été largement comprise dans la seconde moitié des années 1980 et a conduit les concepteurs du MIPS-X à le formuler ainsi en 1987 :

L'objectif de tout format d'instruction doit être : 1. décodage simple, 2. décodage simple et 3. décodage simple. Toute tentative d'amélioration de la densité du code au détriment des performances du processeur doit être ridiculisée à chaque occasion.

La concurrence entre les approches RISC et CISC conventionnelles a également fait l’objet d’analyses théoriques au début des années 1980, conduisant, par exemple, à la loi d’airain des performances des processeurs .

Depuis 2010, une nouvelle architecture de jeu d'instructions standard ouverte (ISA), Berkeley RISC-V , est en cours de développement à l'Université de Californie à Berkeley, à des fins de recherche et comme alternative libre aux ISA propriétaires. En 2014, la version 2 de l' ISA en espace utilisateur est fixe. L'ISA est conçue pour être extensible à partir d'un cœur de base suffisant pour un petit processeur embarqué jusqu'à une utilisation en superordinateur et en cloud computing avec des extensions et coprocesseurs standard et définis par le concepteur de puces. Elle a été testée en conception silicium avec le ROCKET SoC , qui est également disponible en tant que générateur de processeur open source dans le langage CHISEL.

Au début des années 1980, le concept RISC était entouré d'incertitudes importantes. L'une des préoccupations concernait l'utilisation de la mémoire ; une seule instruction d'un processeur traditionnel comme le Motorola 68k pouvait être écrite sous la forme d'une demi-douzaine d'instructions RISC plus simples. En théorie, cela pouvait ralentir le système car il passait plus de temps à extraire les instructions de la mémoire. Mais au milieu des années 1980, les concepts avaient suffisamment mûri pour être considérés comme commercialement viables.

Les conceptions commerciales RISC ont commencé à émerger au milieu des années 1980. L' ARM1 d'Acorn est apparu en avril 1985, le MIPS R2000 est apparu en janvier 1986, suivi peu après par le PA-RISC de Hewlett-Packard dans certains de leurs ordinateurs. Entre-temps, l'effort de Berkeley était devenu si bien connu qu'il est finalement devenu le nom de l'ensemble du concept. En 1987, Sun Microsystems a commencé à livrer des systèmes avec le processeur SPARC , directement basé sur le système Berkeley RISC-II. Le Comité du gouvernement américain sur les innovations en informatique et en communication attribue l'acceptation de la viabilité du concept RISC au succès du système SPARC. En 1989, de nombreux processeurs RISC étaient disponibles ; la concurrence a abaissé leur prix à 10 $ par MIPS en grandes quantités, bien moins cher que le 80386 d'Intel, une source unique . Les performances du processeur RISC d'IBM, disponible uniquement sur le PC RT , étaient moins compétitives que celles des autres, mais le succès de SPARC a renouvelé l'intérêt au sein d'IBM, qui a sorti de nouveaux systèmes RISC en 1990 et en 1995, les processeurs RISC étaient la base d'une industrie de serveurs de 15 milliards de dollars.

À la fin des années 1980, les nouvelles conceptions RISC surpassaient largement toutes les conceptions traditionnelles. À ce moment-là, tous les autres fournisseurs ont commencé à déployer leurs propres efforts en matière de RISC. Parmi ceux-ci figuraient le DEC Alpha , l'AMD Am29000 , l'Intel i860 et l'i960 , le Motorola 88000 , l'IBM POWER et, un peu plus tard, l'IBM/Apple/Motorola PowerPC . Beaucoup d'entre eux ont depuis disparu car ils n'offraient souvent aucun avantage concurrentiel par rapport aux autres de la même époque. Ceux qui restent ne sont souvent utilisés que sur des marchés de niche ou comme éléments d'autres systèmes ; parmi les conceptions de ces fournisseurs traditionnels, seules SPARC et POWER ont encore un marché significatif.

L' architecture ARM a été l'ISA RISC la plus largement adoptée, initialement destinée à fournir des performances informatiques de bureau plus élevées, à faible coût et dans un package thermique restreint, comme dans l' Acorn Archimedes , tout en figurant dans les tableaux de la Super Computer League , son implémentation initiale, relativement plus faible en termes de puissance et de refroidissement, a rapidement été adaptée aux applications embarquées, telles que le traitement d'images raster d'imprimantes laser. Acorn, en partenariat avec Apple Inc et VLSI, a créé ARM Ltd, en 1990, pour partager les coûts de R&D et trouver de nouveaux marchés pour l'ISA, qui, en partenariat avec TI, GEC, Sharp, Nokia, Oracle et Digital, développerait des conceptions RISC à faible consommation et intégrées, et ciblerait ces segments de marché, qui à l'époque étaient de niche. Avec l'essor de l'informatique mobile, automobile, streaming, appareils intelligents, ARM est devenu l'ISA le plus largement utilisé, la société estimant que près de la moitié de tous les processeurs livrés dans l'histoire ont été ARM.

La confusion autour de la définition du RISC découlant de la formulation du terme, ainsi que la tendance à classer de manière opportuniste les architectures de processeur avec relativement peu d'instructions (ou de groupes d'instructions) comme des architectures RISC, ont conduit à des tentatives de définir le RISC comme une philosophie de conception. Une tentative en ce sens a été exprimée comme suit :

Un processeur RISC dispose d'un jeu d'instructions conçu pour une exécution efficace par un processeur pipeline et pour la génération de code par un compilateur optimisant.

—  Michael Slater, Rapport sur les microprocesseurs

L'expression « ordinateur à jeu d'instructions réduit » est souvent mal comprise, car elle suppose que les instructions sont simplement éliminées, ce qui réduit le nombre d'instructions. En fait, au fil des ans, les jeux d'instructions RISC ont augmenté en taille et, aujourd'hui, nombre d'entre eux disposent d'un jeu d'instructions plus important que celui de nombreux processeurs CISC. Certains processeurs RISC, comme le PowerPC, ont des jeux d'instructions aussi importants que ceux du CISC IBM System/370 , par exemple. À l'inverse, le DEC PDP-8, qui est clairement un processeur CISC car bon nombre de ses instructions impliquent plusieurs accès à la mémoire, ne comporte que 8 instructions de base et quelques instructions étendues. Le terme « réduit » dans cette expression visait à décrire le fait que la quantité de travail accomplie par une seule instruction est réduite (au plus un seul cycle de mémoire de données) par rapport aux « instructions complexes » des processeurs CISC qui peuvent nécessiter des dizaines de cycles de mémoire de données pour exécuter une seule instruction.

Le terme architecture de chargement-stockage est parfois préféré.

Une autre façon d'envisager le débat RISC/CISC est de considérer ce qui est exposé au compilateur. Dans un processeur CISC, le matériel peut utiliser en interne des registres et des bits d'indicateur afin d'implémenter une seule instruction complexe telle que STRING MOVE, mais cacher ces détails au compilateur. Les opérations internes d'un processeur RISC sont « exposées au compilateur », ce qui conduit à l' acronyme rétrograde « Relegate Interesting Stuff to the Compiler ».

La plupart des architectures RISC ont des instructions de longueur fixe et un codage simple, ce qui simplifie considérablement la logique de recherche, de décodage et d'émission. C'est l'un des principaux objectifs de l'approche RISC.

Cela n'est possible que grâce au passage contemporain aux formats 32 bits. Par exemple, dans un programme typique, plus de 30 % de toutes les constantes numériques sont soit 0 soit 1, 95 % tiennent dans un octet et 99 % dans une valeur de 16 bits. Lorsque les ordinateurs étaient basés sur des mots de 8 ou 16 bits, il était difficile d'avoir une valeur immédiate combinée avec l'opcode dans un seul mot de mémoire, bien que certaines instructions comme l'incrémentation et la décrémentation le fassent implicitement en utilisant un opcode différent. En revanche, une machine 32 bits a suffisamment de place pour encoder une valeur immédiate, ce qui évite d'avoir à effectuer une deuxième lecture de la mémoire pour récupérer la valeur. C'est pourquoi de nombreux processeurs RISC permettent d'encoder une constante de 12 ou 13 bits directement dans le mot d'instruction.

En supposant une zone constante de 13 bits, comme c'est le cas dans les conceptions MIPS et RISC, 19 bits supplémentaires sont disponibles pour le codage des instructions. Cela laisse suffisamment de place pour indiquer à la fois l'opcode et un ou deux registres. Les opérations de registre à registre, principalement mathématiques et logiques, nécessitent suffisamment de bits pour coder les deux ou trois registres utilisés. La plupart des processeurs utilisent le format à trois opérandes, de la forme A = B + C, auquel cas trois numéros de registres sont nécessaires. Si le processeur dispose de 32 registres, chacun nécessite un numéro de 5 bits, pour 15 bits. Si l'un de ces registres est remplacé par un immédiat, il reste encore beaucoup de place pour coder les deux registres restants et l'opcode. Les instructions courantes trouvées dans les systèmes multi-mots, comme INCet DEC, qui réduisent le nombre de mots à lire avant d'exécuter l'instruction, sont inutiles dans RISC car elles peuvent être accomplies avec un seul registre et la valeur immédiate 1.

Le format RISC-I original reste un exemple canonique du concept. Il utilise 7 bits pour l'opcode et un indicateur de 1 bit pour les codes conditionnels, les 5 bits suivants pour le registre de destination et les cinq suivants pour le premier opérande. Il reste donc 14 bits, dont le premier indique si les 13 suivants contiennent une valeur immédiate ou n'utilise que cinq d'entre eux pour indiquer un registre pour le deuxième opérande. Un exemple plus complexe est le codage MIPS, qui n'utilisait que 6 bits pour l'opcode, suivi de deux registres de 5 bits. Les 16 bits restants pouvaient être utilisés de deux manières, l'une comme valeur immédiate de 16 bits, ou comme valeur de décalage de 5 bits (utilisée uniquement dans les opérations de décalage, sinon zéro) et les 6 bits restants comme extension de l'opcode. Dans le cas des opérations arithmétiques de registre à registre, l'opcode était 0 et les 6 derniers bits contenaient le code réel ; ceux qui utilisaient une valeur immédiate utilisaient le champ opcode normal au début.

L'un des inconvénients des instructions 32 bits est la densité de code réduite, ce qui est une caractéristique plus défavorable dans l'informatique embarquée que sur les marchés des stations de travail et des serveurs pour lesquels les architectures RISC ont été initialement conçues. Pour résoudre ce problème, plusieurs architectures, telles que SuperH (1992), ARM thumb (1994), MIPS16e (2004), Power Variable Length Encoding ISA (2006), RISC-V et Adapteva Epiphany , disposent d'un jeu d'instructions compressées courtes et à fonctionnalités réduites . En général, ces instructions exposent un nombre plus petit de registres et moins de bits pour les valeurs immédiates, et utilisent souvent un format à deux opérandes pour éliminer un numéro de registre des instructions. Un format à deux opérandes dans un système à 16 registres nécessite 8 bits pour les numéros de registre, ce qui en laisse 8 autres pour un opcode ou d'autres utilisations. Le SH5 suit également ce modèle, bien qu'ayant évolué dans la direction opposée, ayant ajouté des instructions 32 bits plus longues à un codage 16 bits d'origine.

L'aspect le plus caractéristique du RISC est l'exécution d'au moins une instruction par cycle . Le fonctionnement à cycle unique est décrit comme « l'exécution rapide de fonctions simples qui dominent le flux d'instructions d'un ordinateur », cherchant ainsi à fournir un débit moyen approchant une instruction par cycle pour tout flux d'instructions unique.

Les autres caractéristiques des architectures RISC incluent :

• Beaucoup moins de transistors dédiés à la logique de base, ce qui a permis aux concepteurs d'augmenter la taille de l'ensemble de registres et d'augmenter le parallélisme interne.
• Format d'instruction uniforme, utilisant un seul mot avec l'opcode dans les mêmes positions de bits pour un décodage plus simple
• Tous les registres à usage général peuvent être utilisés de manière égale comme source/destination dans toutes les instructions, ce qui simplifie la conception du compilateur ( les registres à virgule flottante sont souvent conservés séparément)
• Modes d'adressage simples avec adressage complexe effectué par des séquences d'instructions
• Peu de types de données dans le matériel (pas de chaîne d'octets ou de décimale codée en binaire [BCD], par exemple)

Les conceptions RISC sont également plus susceptibles de comporter un modèle de mémoire Harvard , où le flux d'instructions et le flux de données sont conceptuellement séparés ; cela signifie que la modification de la mémoire où le code est conservé peut n'avoir aucun effet sur les instructions exécutées par le processeur (car le processeur dispose d'un cache d'instructions et de données séparé ), au moins jusqu'à ce qu'une instruction de synchronisation spéciale soit émise ; les processeurs CISC qui ont des caches d'instructions et de données séparés les maintiennent généralement synchronisés automatiquement, pour une compatibilité ascendante avec les anciens processeurs.

De nombreuses conceptions RISC anciennes partageaient également la caractéristique d'avoir un emplacement de délai de branchement , un espace d'instructions immédiatement après un saut ou un branchement. L'instruction dans cet espace est exécutée, que le branchement soit effectué ou non (en d'autres termes, l'effet du branchement est retardé). Cette instruction maintient l' ALU du processeur occupée pendant le temps supplémentaire normalement nécessaire pour effectuer un branchement. De nos jours, l'emplacement de délai de branchement est considéré comme un effet secondaire malheureux d'une stratégie particulière de mise en œuvre de certaines conceptions RISC, et les conceptions RISC modernes l'éliminent généralement (comme PowerPC et les versions plus récentes de SPARC et MIPS).

Certains aspects attribués aux premières conceptions étiquetées RISC vers 1975 incluent les observations selon lesquelles les compilateurs à mémoire restreinte de l'époque étaient souvent incapables de tirer parti des fonctionnalités destinées à faciliter le codage d'assemblage manuel , et que les modes d'adressage complexes nécessitent de nombreux cycles à exécuter en raison des accès mémoire supplémentaires requis. Il a été avancé que de telles fonctions seraient mieux exécutées par des séquences d'instructions plus simples si cela pouvait produire des implémentations suffisamment petites pour laisser de la place à de nombreux registres, réduisant ainsi le nombre d'accès mémoire lents. Dans ces conceptions simples, la plupart des instructions sont de longueur uniforme et de structure similaire, les opérations arithmétiques sont limitées aux registres du processeur et seules les instructions de chargement et de stockage séparées accèdent à la mémoire. Ces propriétés permettent un meilleur équilibrage des étapes du pipeline qu'auparavant, ce qui rend les pipelines RISC nettement plus efficaces et permet des fréquences d'horloge plus élevées .

Une autre impulsion pour le RISC et d’autres conceptions est venue de mesures pratiques sur des programmes du monde réel. Andrew Tanenbaum a résumé bon nombre d’entre elles, démontrant que les processeurs avaient souvent des immédiats surdimensionnés. Par exemple, il a montré que 98 % de toutes les constantes d’un programme tiendraient dans 13 bits , alors que de nombreuses conceptions de CPU dédiaient 16 ou 32 bits pour les stocker. Cela suggère que, pour réduire le nombre d’accès à la mémoire, une machine à longueur fixe pourrait stocker des constantes dans des bits inutilisés du mot d’instruction lui-même, de sorte qu’elles seraient immédiatement prêtes lorsque le processeur en aurait besoin (un peu comme l’adressage immédiat dans une conception conventionnelle). Cela nécessitait de petits opcodes afin de laisser de la place pour une constante de taille raisonnable dans un mot d’instruction de 32 bits.

Étant donné que de nombreux programmes du monde réel passent la majeure partie de leur temps à exécuter des opérations simples, certains chercheurs ont décidé de se concentrer sur la réalisation de ces opérations aussi rapides que possible. La fréquence d'horloge d'un processeur est limitée par le temps nécessaire à l'exécution de la sous-opération la plus lente de toute instruction ; la réduction de ce temps de cycle accélère souvent l'exécution d'autres instructions. L'accent mis sur les « instructions réduites » a conduit à ce que la machine résultante soit appelée « ordinateur à jeu d'instructions réduit » (RISC). L'objectif était de rendre les instructions si simples qu'elles puissent facilement être mises en pipeline, afin d'atteindre un débit d'horloge unique à des fréquences élevées . Cela contrastait avec les conceptions CISC dont les « opérations arithmétiques cruciales et les transferts de registres » étaient considérés comme difficiles à mettre en pipeline.

Plus tard, on a remarqué que l'une des caractéristiques les plus importantes des processeurs RISC était que la mémoire externe n'était accessible que par une instruction de chargement ou de stockage . Toutes les autres instructions étaient limitées aux registres internes. Cela a simplifié de nombreux aspects de la conception des processeurs : permettre aux instructions d'avoir une longueur fixe, simplifier les pipelines et isoler la logique de gestion du retard dans l'achèvement d'un accès à la mémoire (échec de cache, etc.) à seulement deux instructions. Cela a conduit à qualifier les conceptions RISC d' architectures de chargement-stockage .

Certains processeurs ont été spécifiquement conçus pour avoir un très petit ensemble d'instructions, mais ces conceptions sont très différentes des conceptions RISC classiques, c'est pourquoi on leur a donné d'autres noms tels qu'ordinateur à jeu d'instructions minimal (MISC) ou architecture déclenchée par le transport (TTA).

Les architectures RISC ont traditionnellement eu peu de succès sur les marchés des PC de bureau et des serveurs grand public, où les plates-formes x86 restent l'architecture de processeur dominante. Cependant, cela pourrait changer, car les processeurs basés sur ARM sont développés pour des systèmes plus performants. Des fabricants tels que Cavium , AMD et Qualcomm ont sorti des processeurs de serveur basés sur l'architecture ARM. ARM s'est en outre associé à Cray en 2017 pour produire un supercalculateur basé sur ARM. Sur le bureau, Microsoft a annoncé qu'il prévoyait de prendre en charge la version PC de Windows 10 sur les appareils basés sur Qualcomm Snapdragon en 2017 dans le cadre de son partenariat avec Qualcomm. Ces appareils prendront en charge les applications Windows compilées pour x86 32 bits via un émulateur de processeur x86 qui traduit le code x86 32 bits en code ARM64 . Apple a annoncé qu'il allait faire passer ses ordinateurs de bureau et portables Mac des processeurs Intel aux SoC basés sur ARM64 développés en interne, appelés Apple Silicon ; les premiers ordinateurs de ce type, utilisant le processeur Apple M1 , sont sortis en novembre 2020. Les Mac équipés de puces Apple Silicon peuvent exécuter des binaires x86-64 avec Rosetta 2 , un traducteur x86-64 vers ARM64.

En dehors du monde des ordinateurs de bureau, l'architecture ARM RISC est largement utilisée dans les smartphones, les tablettes et de nombreux types d'appareils embarqués. Alors que les premières conceptions RISC différaient considérablement des conceptions CISC contemporaines, en 2000, les processeurs les plus performants de la gamme RISC étaient presque impossibles à distinguer des processeurs les plus performants de la gamme CISC.

Les architectures RISC sont désormais utilisées sur une gamme de plates-formes, des smartphones et tablettes à certains des supercalculateurs les plus rapides au monde tels que Fugaku , le plus rapide de la liste TOP500 en novembre 2020 , et Summit , Sierra et Sunway TaihuLight , les trois suivants sur cette liste.

Au début du 21e siècle, la majorité des systèmes bas de gamme et mobiles s'appuyaient sur des architectures RISC. En voici quelques exemples :

• L' architecture ARM domine le marché des systèmes embarqués à faible consommation et à faible coût (généralement 200-1800 MHz en 2014). Elle est utilisée dans de nombreux systèmes tels que la plupart des systèmes basés sur Android , l' iPhone , l'iPod Touch , l'iPad , l'Apple Watch et l'Apple TV d'Apple , Palm , le Microsoft Windows Phone (anciennement Windows Mobile / Windows CE), les appareils RIM , les Nintendo Game Boy Advance , DS , 3DS et Switch , Raspberry Pi , etc.
• Le PowerPC d'IBM a été utilisé dans les consoles de jeu GameCube , Wii , PlayStation 3 , Xbox 360 et Wii U.
• La gamme MIPS (utilisée à un moment donné dans de nombreux ordinateurs SGI ) était utilisée dans les consoles de jeux PlayStation , PlayStation 2 , Nintendo 64 , PlayStation Portable et les passerelles résidentielles comme la série Linksys WRT54G .
• Le SuperH de Hitachi , à l'origine largement utilisé dans les Sega Super 32X , Saturn et Dreamcast , est désormais développé et vendu par Renesas sous le nom de SH4 .
• Atmel AVR , utilisé dans une variété de produits allant des contrôleurs portables Xbox et de la plate-forme de microcontrôleur open source Arduino aux voitures BMW .
• RISC-V , l'itération actuelle de la norme ouverte RISC ISA de Berkeley, avec des espaces d'adressage de 32 ou 64 bits , un petit ensemble d'instructions entières de base et un ISA « compressé » expérimental pour la densité de code et conçu pour les extensions standard et à usage spécial.

• L'architecture PowerPC d'IBM a été utilisée dans les ordinateurs Macintosh d'Apple à partir de 1994, lorsqu'ils ont commencé à passer des processeurs de la famille Motorola 68000 , jusqu'en 2005, lorsqu'ils sont passés aux processeurs Intel x86 .
• Certains Chromebooks utilisent des plateformes basées sur ARM depuis 2012.
• Apple utilise des processeurs conçus en interne basés sur l'architecture ARM pour sa gamme d'ordinateurs de bureau et portables depuis sa transition des processeurs Intel , et les premiers ordinateurs de ce type sont sortis en novembre 2020.
• Microsoft utilise des processeurs Qualcomm basés sur ARM pour sa gamme Surface . HP Inc et Lenovo ont sorti des PC Windows avec un Qualcomm Snapdragon basé sur ARM .

• MIPS , par Silicon Graphics (a cessé de fabriquer des systèmes basés sur MIPS en 2006).
• SPARC , par Oracle (anciennement Sun Microsystems ) et Fujitsu .
• L'architecture IBM POWER , PowerPC et Power ISA d' IBM étaient et sont utilisées dans de nombreux supercalculateurs, serveurs de milieu de gamme et stations de travail d'IBM.
• PA-RISC de Hewlett-Packard , également connu sous le nom de HP-PA (abandonné fin 2008).
• Alpha , utilisé dans les ordinateurs monocartes , les stations de travail, les serveurs et les supercalculateurs de Digital Equipment Corporation , puis Compaq et enfin Hewlett-Packard (HP) (abandonné à partir de 2007).
• RISC-V , le cinquième ISA RISC de Berkeley, avec des espaces d'adressage de 64 ou 128 bits , et le noyau entier étendu avec des calculs à virgule flottante, atomiques et vectoriels , et conçu pour être étendu avec des instructions pour la mise en réseau, les E/S et le traitement de données. Une spécification pour une conception superscalaire de 64 bits, "Rocket", est disponible en téléchargement. Elle est implémentée dans le processeur de l'European Processor Initiative .
• L' architecture ARM est actuellement utilisée par les fournisseurs de cloud pour les serveurs. Un exemple est le processeur de la série AWS Graviton utilisé pour divers services sur la plateforme AWS. ARM a également été utilisé dans la puce Fujitsu A64FX pour créer Fugaku, le supercalculateur le plus rapide du monde en 2020.

Les architectures RISC sont devenues populaires dans les processeurs open source et les microprocesseurs logiciels car elles sont relativement simples à mettre en œuvre, ce qui les rend adaptées aux implémentations FPGA et au prototypage, par exemple. En voici quelques exemples :

• OpenRISC , un ensemble d'instructions ouvert et une microarchitecture introduite pour la première fois en 2000.
• Architecture MIPS ouverte , pendant une partie de l'année 2019, les spécifications étaient libres d'utilisation, libres de droits, pour les développeurs MIPS enregistrés.
• OpenSPARC , en 2005, Sun a publié sa documentation et ses spécifications Ultra Sparc, sous la licence GPLv2.
  • LEON , une implémentation open source et tolérante aux radiations du jeu d'instructions SPARC V8 (ciblant les applications spatiales).
• Libre-SOC , un SoC open source basé sur Power ISA avec des extensions pour la vidéo et les graphiques 3D.
• RISC-V , en 2010, la version 5 de Berkeley RISC, la spécification, la chaîne d'outils et la marque ont été mises à disposition gratuitement à des fins non commerciales.
• SuperH - J Core , en 2015, un projet visant à proposer des implémentations en salle blanche du Hitachi SuperH RISC ISA, dont le brevet a expiré, a été lancé.
• ARM DesignStart, en 2018 ARM, en partenariat avec le fournisseur FPGA Xilinx, a commencé à offrir un accès gratuit à une partie de la propriété intellectuelle d'ARM, y compris les spécifications FPGA pour certains cœurs de processeur plus anciens.

En 2022, Steve Furber , John L. Hennessy , David A. Patterson et Sophie M. Wilson ont reçu le prix Charles Stark Draper de l' Académie nationale d'ingénierie des États-Unis pour leurs contributions à l'invention, au développement et à la mise en œuvre de puces informatiques à jeu d'instructions réduit (RISC).