Ordinateur à jeu d'instructions réduit - Reduced instruction set computer

Un Sun UltraSPARC , un microprocesseur RISC

Un ordinateur à jeu d'instructions réduit , ou RISC ( / r ɪ s k / ), est un ordinateur avec un petit jeu d'instructions hautement optimisé , plutôt que le jeu plus spécialisé souvent trouvé dans d'autres types d'architecture, comme dans une instruction complexe régler l'ordinateur (CISC). La principale caractéristique distinctive de l'architecture RISC est que le jeu d'instructions est optimisé avec un grand nombre de registres et un pipeline d'instructions très régulier , permettant un faible nombre de cycles d'horloge par instruction (CPI). Les principales caractéristiques d'une philosophie RISC sont une architecture de chargement/stockage , dans laquelle la mémoire est accessible via des instructions spécifiques plutôt que dans le cadre de la plupart des instructions de l'ensemble, et ne nécessitant que des instructions à cycle unique .

Bien qu'un certain nombre d'ordinateurs des années 1960 et 1970 aient été identifiés comme les précurseurs des RISC, le concept moderne date des années 1980. En particulier, deux projets à l'Université de Stanford et à l' Université de Californie à Berkeley sont les plus associés à la vulgarisation de ce concept. Le MIPS de Stanford allait être commercialisé sous le nom d' architecture MIPS à succès , tandis que le RISC de Berkeley a donné son nom à l'ensemble du concept et a été commercialisé sous le nom de SPARC . Un autre succès de cette époque a été l'effort d' IBM qui a finalement conduit à l' architecture de jeu d'instructions IBM POWER , PowerPC et Power ISA . À mesure que ces projets mûrissaient, une variété de conceptions similaires ont fleuri à la fin des années 1980 et surtout au début des années 1990, représentant une force majeure sur le marché des postes de travail Unix ainsi que pour les processeurs intégrés dans les imprimantes laser , les routeurs et les produits similaires.

Les nombreuses variétés de conceptions RISC incluent ARC , Alpha , Am29000 , ARM , Atmel AVR , Blackfin , i860 , i960 , M88000 , MIPS , PA-RISC , Power ISA (y compris PowerPC ), RISC-V , SuperH et SPARC . L'utilisation de processeurs d'architecture ARM dans les smartphones et les tablettes tels que les appareils iPad et Android a fourni une large base d'utilisateurs pour les systèmes basés sur RISC. Les processeurs RISC sont également utilisés dans les supercalculateurs , tels que Fugaku , qui, en juin 2020, est le supercalculateur le plus rapide au monde.

Histoire et développement

La conception du moteur de calcul automatique (ACE) d' Alan Turing en 1946 présentait de nombreuses caractéristiques d'une architecture RISC. Un certain nombre de systèmes, remontant aux années 1960, ont été crédités comme la première architecture RISC, en partie sur la base de leur utilisation de l' approche chargement/stockage . Le terme RISC a été inventé par David Patterson du projet Berkeley RISC , bien que des concepts quelque peu similaires soient 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 de fonctionnement, le cycle d'horloge de base étant 10 fois plus rapide que le temps d'accès mémoire . En partie grâce à l' architecture de chargement/stockage optimisée du CDC 6600, Jack Dongarra affirme 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.

IBM 801

Un microprocesseur IBM PowerPC 601 RISC

Michael J. Flynn considère le premier système RISC comme la conception IBM 801 , commencée en 1975 par John Cocke et achevée en 1980. Le 801 s'est développé à partir d'un effort pour construire un processeur haute vitesse 24 bits à utiliser comme base pour un commutateur téléphonique numérique . Pour atteindre leur objectif de commutation de 300 appels par seconde (1 million par heure), ils ont calculé que le processeur nécessitait des performances de l'ordre de 12 MIPS, par rapport à leur machine mainframe la 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 sur leurs plates-formes existantes. Ceux-ci ont démontré que le code dans les paramètres de haute performance utilisait largement les registres et qu'ils en manquaient souvent. Cela suggérait que des registres supplémentaires amélioreraient encore 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 orthogonal . Au lieu de cela, ils ont sélectionné la version la plus rapide d'une instruction donnée, puis ont construit 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 ont fonctionné de concert ; la suppression d'instructions permettrait aux codes d'instructions d'être plus courts, libérant des bits dans l'instruction qui pourraient ensuite être utilisés pour sélectionner parmi un plus grand ensemble 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 dans la mesure du possible exécuterait le 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 les machines existantes en raison de l'utilisation améliorée des registres. En pratique, leur compilateur expérimental PL/8, une version légèrement réduite de PL/1 , produisait systématiquement du code qui s'exécutait beaucoup plus rapidement sur leurs mainframes.

Une version 32 bits du 801 a finalement été produite sous une forme à puce unique sous le nom d' IBM ROMP en 1981, qui signifiait « Research OPD [Office Products Division] Micro Processor ». Ce processeur a été conçu pour des "mini" tâches, et a également été utilisé dans le PC IBM RT en 1986, qui s'est avéré être un échec commercial. Mais le 801 a inspiré plusieurs projets de recherche, dont de nouveaux chez IBM qui aboutiraient finalement à l' architecture du jeu d'instructions IBM POWER .

RISC et MIPS

À la fin des années 1970, la 801 était devenue bien connue dans l'industrie. Cela coïncidait avec de nouvelles techniques de fabrication qui permettaient 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 nouvelles conceptions 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 le microcode pour ce faire, lisant les instructions et les réimplémentant sous la forme d'une séquence d'instructions internes plus simples. Dans le 68k, plein 1 / 3 des transistors ont été utilisés pour cette microcoding.

En 1979, David Patterson a été envoyé en congé sabbatique de l' Université de Californie à Berkeley pour aider l'équipe de la côte ouest de DEC à 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 microcodage, 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 Berkeley RISC . Le programme, pratiquement inconnu aujourd'hui, a conduit à un grand nombre d'avancées dans la conception, la fabrication et même l'infographie des puces. Considérant une variété de programmes de leur variante BSD Unix , l'équipe de Berkeley a découvert, tout comme 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 qui étaient essentielles à la performance globale étaient retardées par leur passage dans le microcode. Si le microcode était supprimé, les programmes s'exécuteraient plus rapidement. Et puisque le microcode a finalement pris une instruction complexe et l'a divisée en étapes, il n'y avait aucune raison pour que le compilateur ne puisse pas le faire à la place. Ces études suggèrent que, même avec aucun autre changement, on pourrait faire une puce avec 1 / 3 moins de transistors qui iraient plus vite. L'équipe 801 d'IBM l'avait également remarqué ; lorsque les compilateurs étaient confrontés à une sélection d'opcodes possibles, ils choisiraient celui dont les auteurs savaient qu'il avait été optimisé pour s'exécuter le plus rapidement. Cela signifiait que le microcode, qui construisait une séquence d'opérations pour exécuter l'opcode, faisait toujours la même chose encore et encore. Cette tâche introduisait un délai qui pouvait être éliminé si le microcode était supprimé et que le seul opcode réellement utilisé était directement disponible pour le compilateur.

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 faisant la même chose. C'était en partie un effet du fait que de nombreuses conceptions étaient précipité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 célèbre est le VAX de l' INDEXinstruction.

Les travaux de Berkeley ont également permis d'apporter un certain nombre de points supplémentaires. Parmi ceux-ci figurait le fait que les programmes passaient beaucoup de temps à effectuer des appels et des retours de sous-programmes, et il semblait qu'il y avait un potentiel d'amélioration des performances globales en accélérant ces appels. Cela a conduit la conception de Berkeley à sélectionner une méthode connue sous le nom de fenêtres de registre 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 simples missions, seulement 1 / 3 d'entre eux ont effectivement effectué 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étique sous-jacente, par opposition aux conceptions précédentes où la majorité de la puce était dédiée au contrôle et au microcode.

Le Berkeley RISC résultant était basé sur l'amélioration des performances grâce à l'utilisation du pipeline et à l'utilisation agressive du fenêtrage de registre. Dans un processeur traditionnel, on a un petit nombre de registres, et un programme peut utiliser n'importe quel registre à tout moment. Dans une CPU avec des fenêtres de registres, il existe un grand nombre de registres, par exemple 128, mais les programmes ne peuvent en utiliser qu'un petit nombre, par exemple huit, à la fois. Un programme qui se limite à huit registres par procédure peut faire des appels de procédure très rapides : L'appel déplace simplement la fenêtre "vers le bas" de huit, jusqu'à l'ensemble des huit registres utilisés par cette procédure, et le retour recule la fenêtre. Le projet Berkeley RISC a livré le processeur RISC-I en 1982. Composé de seulement 44 420 transistors (contre une moyenne d'environ 100 000 dans les conceptions CISC les plus récentes de l'époque), le RISC-I n'avait que 32 instructions, et pourtant il surpassait complètement tout autre monopuce. conception. Ils ont suivi cela avec le transistor 40 760, 39 instructions RISC-II en 1983, qui a fonctionné trois fois plus vite que RISC-I.

Alors que le projet RISC commençait à être connu dans la Silicon Valley , un projet similaire a commencé à 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 sur l'utilisation du pipeline, s'assurant qu'il pouvait être exécuté aussi « plein » 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 . L'entreprise commerciale a abouti à une nouvelle architecture qui a également été appelée MIPS et le 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 à l'exprimer ainsi en 1987 :

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

Percée commerciale

Prototype de puce RISC-V (2013).

Au début des années 1980, des incertitudes importantes entouraient le concept RISC. Une préoccupation concernait l'utilisation de la mémoire ; une seule instruction d'un processeur traditionnel comme le 68k peut être écrite comme une demi-douzaine d'instructions RISC plus simples. En théorie, cela pourrait ralentir le système car il passe plus de temps à récupérer 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. Le premier 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 connu qu'il est finalement devenu le nom de l'ensemble du concept. En 1987, Sun Microsystems a commencé à commercialiser 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 communications attribue l'acceptation de la viabilité du concept RISC au succès du système SPARC. Le succès de SPARC a renouvelé l'intérêt au sein d'IBM, qui a lancé 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 stade, tous les autres fournisseurs ont commencé leurs propres efforts RISC. Parmi ceux-ci se trouvaient les DEC Alpha , AMD Am29000 , Intel i860 et i960 , Motorola 88000 , IBM POWER et, un peu plus tard, IBM/Apple/Motorola PowerPC . Beaucoup d'entre eux ont disparu depuis car ils n'offrent souvent aucun avantage concurrentiel par rapport à d'autres de la même époque. Ceux qui restent sont souvent utilisés uniquement dans des marchés de niche ou en tant que parties d'autres systèmes, seuls SPARC et POWER ont un marché restant significatif. La valeur aberrante est l' ARM , qui, en partenariat avec Apple, a développé un design basse consommation et s'est ensuite spécialisé sur ce marché, qui à l'époque était une niche. Avec l'essor de l'informatique mobile, en particulier après l'introduction de l' iPhone , ARM est désormais le processeur haut de gamme le plus utilisé sur le marché.

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 (ISA) open source , RISC-V , est en cours de développement à l'Université de Californie à Berkeley, à des fins de recherche et en tant qu'alternative gratuite aux ISA propriétaires. Depuis 2014, la version 2 de l' espace utilisateur ISA est corrigée. L'ISA est conçu pour être extensible à partir d'un noyau barebone suffisant pour un petit processeur intégré à un supercalculateur et une utilisation en nuage avec des extensions et des coprocesseurs définis par le concepteur de puces et standard. Il a été testé 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.

Caractéristiques et philosophie de conception

Philosophie du jeu d'instructions

Un malentendu courant de l'expression "ordinateur à jeu d'instructions réduit" est que les instructions sont simplement éliminées, ce qui entraîne un jeu d'instructions plus petit. En fait, au fil des ans, les jeux d'instructions RISC ont augmenté en taille, et aujourd'hui, beaucoup d'entre eux ont un jeu d'instructions plus important que de nombreux processeurs CISC. Certains processeurs RISC tels que le PowerPC ont des jeux d'instructions aussi grands que le CISC IBM System/370 , par exemple ; à l'inverse, le DEC PDP-8 - clairement un processeur CISC car nombre de ses instructions impliquent plusieurs accès mémoire - n'a que 8 instructions de base et quelques instructions étendues. Le terme "réduit" dans cette phrase était destiné à 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 données. cycles de mémoire afin d'exécuter une seule instruction.

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

Une autre façon d'aborder 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 un bit d'indicateur afin de mettre en œuvre une seule instruction complexe telle que STRING MOVE, mais masquer ces détails au compilateur. Les opérations internes d'un processeur RISC sont "exposées au compilateur", ce qui conduit au backronym "Relegate Interesting Stuff to the Compiler".

Format d'instructions

La plupart des architectures RISC ont des instructions de longueur fixe (généralement 32 bits) et un codage simple, ce qui simplifie considérablement la logique d'extraction, de décodage et d'émission. Un inconvénient des instructions 32 bits est la densité de code réduite, qui est une caractéristique plus défavorable dans l'informatique embarquée qu'elle ne l'est sur les marchés des postes de travail et des serveurs pour lesquels les architectures RISC ont été conçues à l'origine. Pour résoudre ce problème, plusieurs architectures, telles que ARM , Power ISA , MIPS , RISC-V et Adapteva Epiphany , disposent en option d'un format d'instructions courtes à fonctionnalités réduites ou d'une fonctionnalité de compression d'instructions. Le SH5 suit également ce modèle, bien qu'ayant évolué dans la direction opposée, ayant ajouté des instructions multimédias plus longues à un codage original de 16 bits.

Utilisation du matériel

Pour un niveau donné de performances générales, une puce RISC aura généralement beaucoup moins de transistors dédiés à la logique de base, ce qui permettait à l'origine aux concepteurs d'augmenter la taille de l'ensemble de registres et d'augmenter le parallélisme interne.

Les autres caractéristiques des architectures RISC incluent :

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é pourrait ne pas avoir d'effet sur les instructions exécutées par le processeur (car la CPU a une instruction et un cache de données séparés ), 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 automatiquement synchronisés, pour une compatibilité descendante avec les processeurs plus anciens.

De nombreuses premières conceptions RISC partageaient également la caractéristique d'avoir un créneau 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 (c'est-à-dire que l'effet du branchement est retardé). Cette instruction maintient l' ALU du CPU occupé pendant le temps supplémentaire normalement nécessaire pour effectuer un branchement. De nos jours, le slot de délai de branche est considéré comme un effet secondaire malheureux d'une stratégie particulière d'implémentation 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 pour s'exécuter en raison de aux 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 pour 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 CPU et ne séparent que la mémoire d'accès aux instructions de chargement et de stockage . Ces propriétés permettent un meilleur équilibrage des étages de pipeline qu'auparavant, rendant les pipelines RISC beaucoup plus efficaces et permettant des fréquences d'horloge plus élevées .

Encore une autre impulsion de RISC et d'autres conceptions est venue de mesures pratiques sur des programmes du monde réel. Andrew Tanenbaum en a résumé bon nombre, 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 processeurs consacrent 16 ou 32 bits pour les stocker. Cela suggère que, pour réduire le nombre d'accès mémoire, une machine de longueur fixe pourrait stocker des constantes dans les bits inutilisés du mot d'instruction lui-même, afin qu'elles soient immédiatement prêtes lorsque le CPU en a besoin (un peu comme l'adressage immédiat dans une conception conventionnelle) . Cela nécessitait de petits opcodes afin de laisser de la place à 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 plupart 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'une CPU est limitée par le temps qu'il faut pour exécuter la sous-opération la plus lente de n'importe quelle instruction ; la diminution 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 la machine résultante à être appelée « ordinateur à jeu d'instructions réduit » (RISC). L'objectif était de rendre les instructions si simples qu'elles pourraient facilement être mises en pipeline , afin d'obtenir un débit d' horloge unique à hautes fréquences .

Plus tard, il a été noté 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 du processeur : permettre aux instructions d'être de longueur fixe, simplifier les pipelines et isoler la logique pour gérer le retard dans l'achèvement d'un accès mémoire (échec de cache, etc.) à seulement deux instructions. Cela a conduit à ce que les conceptions RISC soient appelées architectures de chargement/stockage .

Comparaison avec d'autres architectures

Certains processeurs ont été spécifiquement conçus pour avoir un très petit jeu d'instructions - mais ces conceptions sont très différentes des conceptions RISC classiques, elles ont donc reçu d'autres noms tels que 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 de base, où les plates- formes basées sur x86 restent l'architecture de processeur dominante. Cependant, cela peut 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 publié des processeurs de serveur basés sur l'architecture ARM. ARM s'est également associé à Cray en 2017 pour produire un supercalculateur basé sur ARM. Sur le bureau, Microsoft a annoncé son intention 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 prennent en charge les applications Windows compilées pour x86 32 bits par l' intermédiaire d' un processeur x86 émulateur qui traduit le code x86 32 bits au code ARM64 . Apple a annoncé qu'ils passeront leurs Mac ordinateurs de bureau et portables de processeurs Intel à base de ARM64 développés en interne SoCs appelé silicium Apple ; les premiers ordinateurs de ce type, utilisant le processeur Apple M1 , sont sortis en novembre 2020. Les Mac avec du silicium Apple peuvent exécuter des binaires x86-64 avec Rosetta 2 , un traducteur x86-64 vers ARM64.

En dehors du domaine des ordinateurs de bureau, cependant, l'architecture ARM RISC est largement utilisée dans les smartphones, les tablettes et de nombreuses formes 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.

Utilisation des architectures RISC

Les architectures RISC sont désormais utilisées sur une gamme de plates-formes, des smartphones et tablettes à certains des superordinateurs 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 prochains sur cette liste.

Systèmes bas de gamme et mobiles

Au début du 21e siècle, la majorité des systèmes bas de gamme et mobiles reposaient sur des architectures RISC. Les exemples comprennent:

Ordinateurs de bureau et portables

Stations de travail, serveurs et supercalculateurs

Voir également

Les références

Liens externes