Architecture du jeu d'instructions

En informatique , une architecture de jeu d'instructions ( ISA ) est un modèle abstrait qui définit généralement la manière dont le logiciel contrôle le processeur d'un ordinateur ou d'une famille d'ordinateurs. Un périphérique ou un programme qui exécute les instructions décrites par cette ISA, comme une unité centrale de traitement (CPU), est appelé une implémentation de cette ISA.

En général, un ISA définit les instructions prises en charge , les types de données , les registres , le support matériel pour la gestion de la mémoire principale , les fonctionnalités fondamentales (telles que la cohérence de la mémoire , les modes d'adressage , la mémoire virtuelle ) et le modèle d'entrée/sortie des implémentations de l'ISA.

Une ISA spécifie le comportement du code machine exécuté sur les implémentations de cette ISA d'une manière qui ne dépend pas des caractéristiques de cette implémentation, offrant une compatibilité binaire entre les implémentations. Cela permet d'utiliser plusieurs implémentations d'une ISA qui diffèrent par des caractéristiques telles que les performances , la taille physique et le coût monétaire (entre autres), mais qui sont capables d'exécuter le même code machine, de sorte qu'une machine moins performante et moins coûteuse peut être remplacée par une machine plus coûteuse et plus performante sans avoir à remplacer le logiciel. Cela permet également l'évolution des microarchitectures des implémentations de cette ISA, de sorte qu'une implémentation plus récente et plus performante d'une ISA puisse exécuter un logiciel qui s'exécute sur des générations d'implémentations précédentes.

Si un système d'exploitation conserve une interface binaire d'application (ABI) standard et compatible pour une ISA particulière, le code machine s'exécutera sur les futures implémentations de cette ISA et de ce système d'exploitation. Cependant, si une ISA prend en charge l'exécution de plusieurs systèmes d'exploitation, cela ne garantit pas que le code machine d'un système d'exploitation s'exécutera sur un autre système d'exploitation, à moins que le premier système d'exploitation ne prenne en charge l'exécution du code machine créé pour l'autre système d'exploitation.

Une ISA peut être étendue en ajoutant des instructions ou d'autres fonctionnalités, ou en ajoutant la prise en charge d'adresses et de valeurs de données plus grandes. Une implémentation de l'ISA étendue pourra toujours exécuter du code machine pour les versions de l'ISA sans ces extensions. Le code machine utilisant ces extensions ne s'exécutera que sur les implémentations qui prennent en charge ces extensions.

La compatibilité binaire qu’ils offrent fait des ISA l’une des abstractions les plus fondamentales de l’informatique .

Une architecture de jeu d'instructions se distingue d'une microarchitecture , qui est l'ensemble des techniques de conception de processeur utilisées, dans un processeur particulier, pour implémenter le jeu d'instructions. Les processeurs dotés de microarchitectures différentes peuvent partager un jeu d'instructions commun. Par exemple, les processeurs Intel Pentium et AMD Athlon implémentent des versions presque identiques du jeu d'instructions x86 , mais leurs conceptions internes sont radicalement différentes.

Le concept d' architecture , distinct de la conception d'une machine spécifique, a été développé par Fred Brooks chez IBM lors de la phase de conception du System/360 .

Avant NPL [System/360], les concepteurs d'ordinateurs de la société étaient libres de respecter les objectifs de coût non seulement en sélectionnant les technologies mais aussi en élaborant des améliorations fonctionnelles et architecturales. L'objectif de compatibilité SPREAD, en revanche, postulait une architecture unique pour une série de cinq processeurs couvrant une large gamme de coûts et de performances. Aucune des cinq équipes de conception technique ne pouvait compter sur la capacité d'apporter des ajustements aux spécifications architecturales pour atténuer les difficultés liées à la réalisation des objectifs de coût et de performance.

Certaines machines virtuelles qui prennent en charge le bytecode comme leur ISA, comme Smalltalk , la machine virtuelle Java et le Common Language Runtime de Microsoft , implémentent cette fonction en traduisant le bytecode des chemins de code fréquemment utilisés en code machine natif. De plus, ces machines virtuelles exécutent les chemins de code moins fréquemment utilisés par interprétation (voir : Compilation juste-à-temps ). Transmeta a implémenté le jeu d'instructions x86 sur les processeurs VLIW de cette manière.

Un ISA peut être classé de différentes manières. Une classification courante est celle de la complexité architecturale . Un ordinateur à jeu d'instructions complexe (CISC) comporte de nombreuses instructions spécialisées, dont certaines ne sont que rarement utilisées dans des programmes pratiques. Un ordinateur à jeu d'instructions réduit (RISC) simplifie le processeur en implémentant efficacement uniquement les instructions fréquemment utilisées dans les programmes, tandis que les opérations moins courantes sont implémentées sous forme de sous-routines, le temps d'exécution supplémentaire du processeur qui en résulte étant compensé par une utilisation peu fréquente.

D'autres types incluent les architectures à très long mot d'instruction (VLIW) et les architectures à long mot d'instruction (LIW) et à calcul d'instructions explicitement parallèles (EPIC) qui leur sont étroitement liées. Ces architectures cherchent à exploiter le parallélisme au niveau des instructions avec moins de matériel que RISC et CISC en rendant le compilateur responsable de l'émission et de la planification des instructions.

Des architectures encore moins complexes ont été étudiées, comme l' ordinateur à jeu d'instructions minimal (MISC) et l'ordinateur à jeu d'instructions unique (OISC). Ces types sont théoriquement importants, mais n'ont pas été commercialisés.

Le langage machine est construit à partir d'instructions discrètes . Sur l'architecture de traitement, une instruction donnée peut spécifier :

• opcode (l'instruction à exécuter) par exemple ajouter, copier, tester
• tous les opérandes explicites :

registres

valeurs littérales/constantes

modes d'adressage utilisés pour accéder à la mémoire

Des opérations plus complexes sont construites en combinant ces instructions simples, qui sont exécutées séquentiellement ou comme indiqué par les instructions de flux de contrôle .

Voici des exemples d’opérations communes à de nombreux ensembles d’instructions :

• Définir un registre sur une valeur constante fixe.
• Copier des données d'un emplacement mémoire ou d'un registre vers un emplacement mémoire ou un registre (une instruction machine est souvent appelée move ; cependant, le terme est trompeur). Elles sont utilisées pour stocker le contenu d'un registre, le contenu d'un autre emplacement mémoire ou le résultat d'un calcul, ou pour récupérer des données stockées afin d'effectuer un calcul dessus ultérieurement. Elles sont souvent appelées opérations de chargement et de stockage .
• Lire et écrire des données à partir de périphériques matériels.

• Ajouter , soustraire , multiplier ou diviser les valeurs de deux registres, en plaçant le résultat dans un registre, en définissant éventuellement un ou plusieurs codes de condition dans un registre d'état .
  • incrément ,décrémente dans certains ISA, économisant la récupération d'opérande dans les cas triviaux.
• Effectuer des opérations au niveau du bit , par exemple en prenant la conjonction et la disjonction de bits correspondants dans une paire de registres, en prenant la négation de chaque bit dans un registre.
• Comparer deux valeurs dans des registres (par exemple, pour voir si l'une est inférieure ou si elles sont égales).
• Instructions à virgule flottante pour l'arithmétique sur les nombres à virgule flottante.

• Accédez à un autre emplacement dans le programme et exécutez les instructions à cet endroit.
• Branchez-vous conditionnellement vers un autre emplacement si une certaine condition est remplie.
• Branche indirecte vers un autre emplacement.
• Appelez un autre bloc de code, tout en enregistrant l’emplacement de l’instruction suivante comme point de retour.

• Charger/stocker des données vers et depuis un coprocesseur ou échanger avec les registres du processeur.
• Effectuer des opérations de coprocesseur.

Les processeurs peuvent inclure des instructions « complexes » dans leur jeu d'instructions. Une seule instruction « complexe » effectue une tâche qui peut nécessiter de nombreuses instructions sur d'autres ordinateurs. Ces instructions sont caractérisées par des instructions qui prennent plusieurs étapes, contrôlent plusieurs unités fonctionnelles ou apparaissent à une échelle plus grande que la masse des instructions simples implémentées par le processeur donné. Voici quelques exemples d'instructions « complexes » :

• transférer plusieurs registres vers ou depuis la mémoire (en particulier la pile ) à la fois
• déplacer de gros blocs de mémoire (par exemple, copie de chaîne ou transfert DMA )
• arithmétique complexe d'entiers et de virgule flottante (par exemple, racine carrée ou fonctions transcendantes telles que logarithme , sinus , cosinus , etc.)
• Instruction SIMD s, une instruction unique effectuant une opération sur plusieurs valeurs homogènes en parallèle, éventuellement dansdes registres SIMD
• exécuter une instruction atomique de test et de définition ou une autre instruction atomique de lecture-modification-écriture
• instructions qui effectuent des opérations ALU avec un opérande de la mémoire plutôt qu'un registre

Les instructions complexes sont plus courantes dans les jeux d'instructions CISC que dans les jeux d'instructions RISC, mais les jeux d'instructions RISC peuvent également les inclure. Les jeux d'instructions RISC n'incluent généralement pas d'opérations ALU avec des opérandes de mémoire, ni d'instructions pour déplacer de gros blocs de mémoire, mais la plupart des jeux d'instructions RISC incluent des instructions SIMD ou vectorielles qui effectuent la même opération arithmétique sur plusieurs éléments de données en même temps. Les instructions SIMD ont la capacité de manipuler de grands vecteurs et matrices en un minimum de temps. Les instructions SIMD permettent une parallélisation facile des algorithmes couramment utilisés dans le traitement du son, de l'image et de la vidéo. Diverses implémentations SIMD ont été commercialisées sous des noms commerciaux tels que MMX , 3DNow! et AltiVec .

Dans les architectures traditionnelles, une instruction comprend un opcode qui spécifie l'opération à effectuer, comme ajouter le contenu de la mémoire au registre , et zéro ou plusieurs spécificateurs d'opérandes , qui peuvent spécifier des registres , des emplacements de mémoire ou des données littérales. Les spécificateurs d'opérandes peuvent avoir des modes d'adressage déterminant leur signification ou peuvent se trouver dans des champs fixes. Dans les architectures à très long mot d'instruction (VLIW), qui incluent de nombreuses architectures à microcode , plusieurs opcodes et opérandes simultanés sont spécifiés dans une seule instruction.

Certains ensembles d'instructions exotiques n'ont pas de champ d'opcode, comme les architectures déclenchées par transport (TTA), mais uniquement des opérandes.

La plupart des machines à pile ont des jeux d'instructions « 0-opérande » dans lesquels les opérations arithmétiques et logiques n'ont pas de champs de spécification d'opérande ; seules les instructions qui poussent les opérandes sur la pile d'évaluation ou qui font sortir les opérandes de la pile dans des variables ont des spécificateurs d'opérande. Le jeu d'instructions exécute la plupart des actions ALU avec des opérations postfixées ( notation polonaise inversée ) qui ne fonctionnent que sur la pile d'expressions , et non sur des registres de données ou des cellules de mémoire principale arbitraires. Cela peut être très pratique pour compiler des langages de haut niveau, car la plupart des expressions arithmétiques peuvent être facilement traduites en notation postfixée.

Les instructions conditionnelles comportent souvent un champ de prédicat, c'est-à-dire quelques bits qui codent la condition spécifique pour qu'une opération soit exécutée plutôt que non exécutée. Par exemple, une instruction de branchement conditionnel transférera le contrôle si la condition est vraie, de sorte que l'exécution se poursuivra vers une autre partie du programme, et ne transférera pas le contrôle si la condition est fausse, de sorte que l'exécution se poursuivra de manière séquentielle. Certains jeux d'instructions comportent également des déplacements conditionnels, de sorte que le déplacement sera exécuté et les données stockées dans l'emplacement cible, si la condition est vraie, et non exécutées, et l'emplacement cible ne sera pas modifié, si la condition est fausse. De même, IBM z/Architecture comporte une instruction de stockage conditionnelle. Quelques jeux d'instructions incluent un champ de prédicat dans chaque instruction ; c'est ce qu'on appelle la prédication de branchement .

Les ensembles d'instructions peuvent être classés en fonction du nombre maximal d'opérandes explicitement spécifiés dans les instructions.

(Dans les exemples qui suivent, a , b et c sont des adresses (directes ou calculées) faisant référence à des cellules mémoire, tandis que reg1 et ainsi de suite font référence à des registres machine.)

C = A+B 

• Opérande 0 ( machines à adresse zéro ), dites machines à pile : Toutes les opérations arithmétiques se déroulent en utilisant la ou les deux premières positions de la pile : push a , push b, add, pop c.
  • C = A+Bnécessite quatre instructions . Pour les machines à pile, les termes « opérande 0 » et « adresse zéro » s'appliquent aux instructions arithmétiques, mais pas à toutes les instructions, car les instructions push et pop à 1 opérande sont utilisées pour accéder à la mémoire.
• Les machines à 1 opérande ( machines à une adresse ), appelées machines à accumulateur , incluent les premiers ordinateurs et de nombreux petits microcontrôleurs : la plupart des instructions spécifient un seul opérande droit (c'est-à-dire une constante, un registre ou un emplacement mémoire), avec l' accumulateur implicite comme opérande gauche (et la destination s'il y en a un) : load a, add b, store c.
  • C = A+Bnécessite trois instructions .
• 2 opérandes — de nombreuses machines CISC et RISC entrent dans cette catégorie :
  • CISC — move Avers C ; puis add Bvers C .
    • C = A+Bnécessite deux instructions . Cela « stocke » effectivement le résultat sans instruction de stockage explicite .
  • CISC — Souvent, les machines sont limitées à un opérande mémoire par instruction : load a,reg1; add b,reg1; store reg1,c; Cela nécessite une paire chargement/stockage pour tout mouvement de mémoire, que le addrésultat soit une augmentation stockée à un emplacement différent, comme dans C = A+B, ou au même emplacement mémoire : A = A+B.
    • C = A+Bnécessite trois instructions .
  • RISC — Nécessitant des chargements de mémoire explicites, les instructions seraient : load a,reg1; load b,reg2; add reg1,reg2; store reg2,c.
    • C = A+Bnécessite quatre instructions .
• 3 opérandes, permettant une meilleure réutilisation des données :
  • CISC — Cela devient soit une instruction unique :add a,b,c
    • C = A+Bnécessite une instruction .
  • CISC — Ou, sur les machines limitées à deux opérandes mémoire par instruction, move a,reg1; add reg1,b,c;
    • C = A+Bnécessite deux instructions .
  • RISC — les instructions arithmétiques utilisent uniquement des registres, des instructions explicites de chargement/stockage à 2 opérandes sont donc nécessaires : load a,reg1; load b,reg2; add reg1+reg2->reg3; store reg3,c;
    • C = A+Bnécessite quatre instructions .
    • Contrairement aux opérandes à 2 ou 1 opérande, cela laisse les trois valeurs a, b et c dans les registres disponibles pour une réutilisation ultérieure.
• plus d'opérandes : certaines machines CISC autorisent une variété de modes d'adressage qui autorisent plus de 3 opérandes (registres ou accès mémoire), comme l' instruction d'évaluation polynomiale VAX « POLY ».

En raison du grand nombre de bits nécessaires pour coder les trois registres d'une instruction à 3 opérandes, les architectures RISC qui ont des instructions de 16 bits sont invariablement des conceptions à 2 opérandes, telles que l'Atmel AVR, le TI MSP430 et certaines versions de l'ARM Thumb . Les architectures RISC qui ont des instructions de 32 bits sont généralement des conceptions à 3 opérandes, telles que les architectures ARM , AVR32 , MIPS , Power ISA et SPARC .

Chaque instruction spécifie explicitement un certain nombre d'opérandes (registres, emplacements mémoire ou valeurs immédiates) . Certaines instructions donnent un ou les deux opérandes implicitement, par exemple en les stockant au sommet de la pile ou dans un registre implicite. Si certains des opérandes sont donnés implicitement, moins d'opérandes doivent être spécifiés dans l'instruction. Lorsqu'un « opérande de destination » spécifie explicitement la destination, un opérande supplémentaire doit être fourni. Par conséquent, le nombre d'opérandes codés dans une instruction peut différer du nombre mathématiquement nécessaire d'arguments pour une opération logique ou arithmétique (l' arité ). Les opérandes sont soit codés dans la représentation « opcode » de l'instruction, soit donnés sous forme de valeurs ou d'adresses suivant l'opcode.

La pression des registres mesure la disponibilité des registres libres à tout moment pendant l'exécution du programme. La pression des registres est élevée lorsqu'un grand nombre de registres disponibles sont utilisés ; ainsi, plus la pression des registres est élevée, plus le contenu des registres doit être versé en mémoire. L'augmentation du nombre de registres dans une architecture diminue la pression des registres mais augmente le coût.

Alors que les jeux d'instructions intégrés tels que Thumb souffrent d'une pression de registre extrêmement élevée en raison de leurs petits jeux de registres, les ISA RISC à usage général comme MIPS et Alpha bénéficient d'une faible pression de registre. Les ISA CISC comme x86-64 offrent une faible pression de registre malgré des jeux de registres plus petits. Cela est dû aux nombreux modes d'adressage et optimisations (tels que l'adressage de sous-registres, les opérandes de mémoire dans les instructions ALU, l'adressage absolu, l'adressage relatif au PC et les débordements de registre à registre) qu'offrent les ISA CISC.

La taille ou la longueur d'une instruction varie considérablement, de seulement quatre bits dans certains microcontrôleurs à plusieurs centaines de bits dans certains systèmes VLIW . Les processeurs utilisés dans les ordinateurs personnels , les ordinateurs centraux et les supercalculateurs ont des tailles d'instruction minimales comprises entre 8 et 64 bits. L'instruction la plus longue possible sur x86 est de 15 octets (120 bits). Dans un jeu d'instructions, différentes instructions peuvent avoir des longueurs différentes. Dans certaines architectures, notamment la plupart des ordinateurs à jeu d'instructions réduit (RISC),Les instructions ont une longueur fixe , correspondant généralement à la taille de mot de cette architecture. Dans d'autres architectures, les instructions ont une longueur variable , généralement des multiples entiers d'un octet ou d'un demi-mot . Certaines, comme l' ARM avec extension Thumb, ont un codage variable mixte , c'est-à-dire deux codages fixes, généralement 32 bits et 16 bits, où les instructions ne peuvent pas être mélangées librement mais doivent être commutées entre elles sur une branche (ou une limite d'exception dans ARMv8).

Les instructions de longueur fixe sont moins compliquées à gérer que les instructions de longueur variable pour plusieurs raisons (ne pas avoir à vérifier si une instruction chevauche une ligne de cache ou une limite de page de mémoire virtuelle, par exemple), et sont donc un peu plus faciles à optimiser en termes de vitesse.

Au début des années 1960, la mémoire principale était coûteuse et très limitée, même sur les ordinateurs centraux. Il était souvent essentiel de minimiser la taille d'un programme pour s'assurer qu'il tiendrait dans la mémoire limitée. Ainsi, la taille des instructions nécessaires pour effectuer une tâche particulière, la densité du code , était une caractéristique importante de tout jeu d'instructions. Elle est restée importante sur les mémoires initialement minuscules des mini-ordinateurs, puis sur les microprocesseurs. La densité reste importante aujourd'hui, pour les applications pour smartphones, les applications téléchargées dans les navigateurs via des connexions Internet lentes et dans les ROM pour les applications embarquées. Un avantage plus général d'une densité accrue est l'amélioration de l'efficacité des caches et de la prélecture des instructions.

Les ordinateurs à haute densité de code ont souvent des instructions complexes pour la saisie de procédures, les retours paramétrés, les boucles, etc. (d'où leur nom rétroactif d'ordinateurs à jeu d'instructions complexe , CISC ). Cependant, les instructions « CISC » plus courantes ou plus fréquentes combinent simplement une opération ALU de base, telle que « ajouter », avec l'accès à un ou plusieurs opérandes en mémoire (en utilisant des modes d'adressage tels que direct, indirect, indexé, etc.). Certaines architectures peuvent autoriser deux ou trois opérandes (y compris le résultat) directement en mémoire ou peuvent être capables d'exécuter des fonctions telles que l'incrémentation automatique du pointeur, etc. Les jeux d'instructions implémentés par logiciel peuvent avoir des instructions encore plus complexes et puissantes.

Les ordinateurs à jeu d'instructions réduit , RISC , ont été largement mis en œuvre pour la première fois à une époque où les sous-systèmes de mémoire se développaient rapidement. Ils sacrifiaient la densité du code pour simplifier les circuits d'implémentation et essayaient d'augmenter les performances via des fréquences d'horloge plus élevées et davantage de registres. Une seule instruction RISC n'effectue généralement qu'une seule opération, comme un « ajout » de registres ou un « chargement » d'un emplacement de mémoire vers un registre. Un jeu d'instructions RISC a normalement une longueur d'instruction fixe, tandis qu'un jeu d'instructions CISC typique a des instructions de longueur très variable. Cependant, comme les ordinateurs RISC nécessitent normalement des instructions plus nombreuses et souvent plus longues pour implémenter une tâche donnée, ils font par nature une utilisation moins optimale de la bande passante du bus et des mémoires cache.

Certains ISA RISC intégrés comme Thumb et AVR32 présentent généralement une densité très élevée en raison d'une technique appelée compression de code. Cette technique regroupe deux instructions de 16 bits en un seul mot de 32 bits, qui est ensuite décompressé au stade du décodage et exécuté comme deux instructions.

Les ordinateurs à jeu d'instructions minimal (MISC) sont généralement une forme de machine à pile , où il y a peu d'instructions séparées (8 à 32), de sorte que plusieurs instructions peuvent être insérées dans un seul mot machine. Ces types de cœurs nécessitent souvent peu de silicium pour être mis en œuvre, ils peuvent donc être facilement réalisés dans un FPGA ou sous une forme multicœur . La densité de code du MISC est similaire à la densité de code du RISC ; la densité d'instructions accrue est compensée par la nécessité d'un plus grand nombre d'instructions primitives pour effectuer une tâche.

Des recherches ont été menées sur la compression des exécutables comme mécanisme d'amélioration de la densité du code. Les mathématiques de la complexité de Kolmogorov décrivent les défis et les limites de ce mécanisme.

En pratique, la densité du code dépend également du compilateur . La plupart des compilateurs optimisants ont des options qui contrôlent s'il faut optimiser la génération de code pour la vitesse d'exécution ou pour la densité du code. Par exemple, GCC a l'option -Os pour optimiser la taille du code machine et -O3 pour optimiser la vitesse d'exécution au détriment d'un code machine plus volumineux.

Les instructions constituant un programme sont rarement spécifiées en utilisant leur forme numérique interne ( code machine ) ; elles peuvent être spécifiées par des programmeurs utilisant un langage assembleur ou, plus communément, peuvent être générées à partir de langages de programmation de haut niveau par des compilateurs .

La conception des jeux d'instructions est une question complexe. L'histoire du microprocesseur a connu deux phases. La première a été le CISC (Complex Instruction Set Computer), qui comportait de nombreuses instructions différentes. Dans les années 1970, cependant, des entreprises comme IBM ont fait des recherches et ont découvert que de nombreuses instructions de ce jeu pouvaient être éliminées. Le résultat a été le RISC (Reduced Instruction Set Computer), une architecture qui utilise un jeu d'instructions plus petit. Un jeu d'instructions plus simple peut offrir le potentiel d'une vitesse plus élevée, d'une taille de processeur réduite et d'une consommation d'énergie réduite. Cependant, un jeu d'instructions plus complexe peut optimiser les opérations courantes, améliorer l'efficacité de la mémoire et du cache ou simplifier la programmation.

Certains concepteurs de jeux d'instructions réservent un ou plusieurs opcodes à un type d' appel système ou d'interruption logicielle . Par exemple, MOS Technology 6502 utilise 00 _H , Zilog Z80 utilise les huit codes C7, CF, D7, DF, E7, EF, F7, FF _H tandis que Motorola 68000 utilise des codes dans la plage A000..AFFF _H .

Les machines virtuelles rapides sont beaucoup plus faciles à mettre en œuvre si un jeu d'instructions répond aux exigences de virtualisation de Popek et Goldberg .

Le glissement NOP utilisé dans la programmation tenant compte de l'immunité est beaucoup plus facile à mettre en œuvre si l'état « non programmé » de la mémoire est interprété comme un NOP .

Sur les systèmes dotés de plusieurs processeurs, les algorithmes de synchronisation non bloquants sont beaucoup plus faciles à implémenter si le jeu d'instructions inclut la prise en charge de quelque chose comme « fetch-and-add », « load-link/store-conditional » (LL/SC) ou « atomic compare-and-swap ».

Un jeu d'instructions donné peut être implémenté de diverses manières. Toutes les façons d'implémenter un jeu d'instructions particulier fournissent le même modèle de programmation , et toutes les implémentations de ce jeu d'instructions sont capables d'exécuter les mêmes exécutables. Les différentes façons d'implémenter un jeu d'instructions donnent lieu à différents compromis entre coût, performances, consommation d'énergie, taille, etc.

Lors de la conception de la microarchitecture d'un processeur, les ingénieurs utilisent des blocs de circuits électroniques « câblés » (souvent conçus séparément) tels que des additionneurs, des multiplexeurs, des compteurs, des registres, des ALU, etc. Un certain type de langage de transfert de registre est alors souvent utilisé pour décrire le décodage et le séquençage de chaque instruction d'un ISA utilisant cette microarchitecture physique. Il existe deux manières de base de construire une unité de contrôle pour implémenter cette description (bien que de nombreuses conceptions utilisent des moyens intermédiaires ou des compromis) :

1. Certaines conceptions informatiques « câblent en dur » l'ensemble complet des instructions de décodage et de séquençage (tout comme le reste de la microarchitecture).
2. D'autres conceptions utilisent des routines de microcode ou des tables (ou les deux) pour ce faire, en utilisant des ROM ou des RAM inscriptibles ( magasin de contrôle inscriptible ), des PLA ou les deux.

Certaines conceptions de processeurs microcodés avec un magasin de contrôle inscriptible l'utilisent pour permettre la modification du jeu d'instructions (par exemple, le processeur Rekursiv et le Imsys Cjip).

Les processeurs conçus pour le calcul reconfigurable peuvent utiliser des réseaux de portes programmables sur site (FPGA).

Un ISA peut également être émulé dans un logiciel par un interpréteur . Naturellement, en raison de la charge d'interprétation, cette opération est plus lente que l'exécution directe de programmes sur le matériel émulé, à moins que le matériel exécutant l'émulateur ne soit d'un ordre de grandeur plus rapide. Aujourd'hui, il est courant pour les fournisseurs de nouveaux ISA ou de microarchitectures de mettre des émulateurs logiciels à la disposition des développeurs de logiciels avant que l'implémentation matérielle ne soit prête.

Souvent, les détails de l'implémentation ont une forte influence sur les instructions particulières sélectionnées pour le jeu d'instructions. Par exemple, de nombreuses implémentations du pipeline d'instructions n'autorisent qu'un seul chargement ou stockage de mémoire par instruction, ce qui conduit à une architecture de chargement-stockage (RISC). Par exemple, certaines des premières façons d'implémenter le pipeline d'instructions ont conduit à un créneau de retard .

Les exigences du traitement de signaux numériques à grande vitesse ont évolué dans la direction opposée, obligeant à implémenter les instructions d'une manière particulière. Par exemple, pour exécuter des filtres numériques suffisamment rapidement, l'instruction MAC d'un processeur de signal numérique (DSP) classique doit utiliser une sorte d' architecture Harvard capable de récupérer une instruction et deux mots de données simultanément, et nécessite un multiplicateur de multiplication-accumulation à cycle unique .