« Fonctionnement d'un ordinateur/Les jeux d'instructions » : différence entre les versions

m
m (→‎Avantages et désavantages : Vu que les programmes créés pour ces machines sont souvent très petits, on dit que la code density (la densité du code) est bonne. Par contre, une)
Les instructions d'un processeur dépendent fortement du processeur utilisé. La liste de toute les instructions qu'un processeur peut exécuter s'appelle son '''jeu d'instructions'''. Celui-ci définit les instructions supportées, ainsi que la manière dont elles sont encodées en mémoire. Le jeu d'instruction de nos PC qui fonctionnent sous Windows est appelé le x86. C'est un jeu d'instructions particulièrement ancien, apparu certainement avant votre naissance : 1978. Depuis, de plus en plus d'instructions ont été ajoutées et rajoutées : ces instructions sont ce qu'on appelle des extensions x86. On peut citer par exemple les extensions MMX, SSE, SSE2, voir 3dnow!. Les anciens macintoshs (la génération de macintosh produits entre 1994 et 2006) utilisaient un jeu d'instruction différent : le PowerPC (depuis 2006, les macintoshs utilisent un processeur X86). Mais les architectures x86 et Power PC ne sont pas les seules au monde : il existe d'autres types d'architectures qui sont très utilisées dans le monde de l’informatique embarquée et dans tout ce qui est tablettes et téléphones portables derniers cris. On peut citer notamment l'architecture ARM, qui domine ce marché. Et n'oublions pas leurs consœurs MIPS et SPARC. Pour résumer, il existe différents jeux d'instructions, que l'on peut classer suivant divers critères.
 
==AdressageL'adressage des opérandes==
 
La première classification que nous allons voir est celle basée sur l'adressage des opérandes, et les transferts de données entre mémoire, unité de calcul, et registres. Le critère de distinction entre ces architectures est les modes d'adressage autorisés pour les instructions de calcul. Les accès mémoire et branchements ne sont pas vraiment impliqués dans cette classification. La raison à cela est que les branchements ont des modes d'adressages dédiés, tandis que les accès mémoire ont besoin de beaucoup de modes d'adressage pour faire leur travail. Tel n'est pas le cas des instructions de calculs, qui peuvent utiliser un nombre limité de modes d'adressage sans le moindre problèmes. Certaines architectures ont décidé de limiter les modes d'adressages pour les calculs, afin de simplifier le processeur ou le travail du compilateur. D'autres ont décidé d'utiliser beaucoup de modes d'adressage, dans un souci de flexibilité ou de performances. Bref, voyons comment les différents types d'architectures ont géré le cas des modes d'adressages pour les instructions de calcul.
{|class="wikitable"
|-
! Classe d'architecture
! Intermédiaire entre la mémoire RAM et le reste du processeur
|-
| Architecture mémoire-mémoire
| Aucun. Les opérandes sont lues en RAM et les résultats y sont aussi écrits
|-
| Architecture à registres
| Registres. Les opérandes et résultats sont placés dans des registres.
|-
| Architecture à pile/à file
| Mémoire FIFO/LIFO. Les opérandes et résultats sont placés dans une mémoire FIFO ou LIFO.
|}
 
===ArchitectureLes architectures mémoire-mémoire===
 
Les toutes premières machines n'avaient pas de registres pour les données et ne faisaient que manipuler la mémoire RAM ou ROM : on parle d''''architectures mémoire-mémoire'''. Dans cette architecture ci, il n'y a pas de registres généraux : les instructions n'accèdent qu'à la mémoire principale. Néanmoins, les registres d'instruction et pointeur d'instruction existent toujours. Les seules opérandes possibles pour ces processeurs sont des adresses mémoire, ce qui fait qu'un mode d'adressage est très utilisé : l'adressage absolu. Ces architectures avaient l'avantage d'avoir une gestion de la mémoire assez simple. Le nombre d'instruction d'accès mémoire était assez important, en raison de l'absence de registres, chose essentielle sur les architectures modernes. Ce genre d'architectures est aujourd'hui tombé en désuétude depuis que la mémoire est devenue très lente comparé au processeur.
 
[[File:Ismem2mem.png|centre|vignette|Architecture mémoire-mémoire.]]
 
===Les architectures à registres===
Les architectures mémoire-mémoire ont un défaut rédhibitoire : elles n'ont pas de registres pour stocker leurs opérandes. La conséquence est que les performances sont mauvaises, la RAM étant assez lente par rapport aux registres du processeur. Et encore une fois, les chercheurs et ingénieurs ont inventé des architectures qui résolvent ce problème : les '''architectures à registres'''. Celles-ci possèdent des registres qui permettent de conserver temporairement une opérande destinée à être utilisée souvent, ou des résultats de calculs temporaires. Il en existe plusieurs sous-types, qui se distinguent par leur nombre de registres pour les opérandes et par leurs modes d'adressages.
 
====ArchitecturesLes architectures à accumulateur====
 
Certains processeurs n'utilisent qu'un seul registre pour les données : l''''accumulateur'''. Toute instruction arithmétique va lire un opérande depuis cet accumulateur, et y écrire son résultat. Si l'instruction a besoin de plusieurs opérandes, les opérandes qui ne sont pas dans l'accumulateur sont lus depuis la mémoire ou dans des registres séparés de l'accumulateur. Dans tous les cas, l'accumulateur est localisé grâce au mode d'adressage implicite. De plus, le résultat des instructions arithmétiques et logiques est stocké dans l'accumulateur, et on n'a pas besoin de préciser où stocker le résultat : pas de mode d'adressage pour le résultat. Par contre, les autres opérandes sont localisées avec d'autres modes d'adressage : absolu pour le cas le plus fréquent, inhérent (à registre) sur certaines architectures, indirect à registre pour d'autres, etc.
 
[[File:Isaccumulator.png|centre|vignette|Architecture à accumulateur.]]
 
Historiquement, les premières architectures à accumulateur ne contenaient aucun autre registre : l'accumulateur était seul au monde. Pour faire ses calculs, notre processeur devait stocker une opérande dans l'accumulateur, et aller chercher les autres en mémoire. Sur ces processeurs, les modes d'adressages supportés étaient les modes d'adressages implicite, absolus, et immédiat. Ces architectures sont parfois appelées '''architectures 1-adresse''', pour une raison simple : la majorité des instructions devait lire une opérande depuis la RAM. Il faut dire que la majorité des instructions d'un processeur n'a besoin que de deux opérandes et ne fournissent qu'un résultat : pensez aux instructions d'addition, de multiplication, de division, etc. Pour ces opérations, le résultat ainsi qu'une des opérandes sont stockés dans l'accumulateur, et adressés de façon implicite, seule la seconde opérande étant adressée directement.
Les '''processeurs à registres''' peuvent stocker temporairement des données dans des registres généraux ou spécialisés. Pour échanger des données entre la mémoire et les registres, on peut utiliser une instruction à tout faire : MOV. Sur d'autres, on utilise des instructions séparées pour copier une donnée de la mémoire vers un registre (LOAD), copier le contenu d'un registre dans un autre, copier le contenu d'un registre dans la mémoire RAM (STORE), etc.
 
[[File:Isregmem.png|centre|vignette|Architecture à registres.]]
 
Ces architectures à registres généraux (ainsi que les architectures Load-Store qu'on verra juste après) sont elles-même divisées en deux sous-classes bien distinctes : les architectures 2 adresses et les architectures 3 adresses. Cette distinction entre architecture 2 et 3 adresses permet de distinguer les modes d'adressages des opérations arithmétiques manipulant deux données : additions, multiplications, soustraction, division, etc. Ces instructions ont donc besoin d'adresser deux données différentes, et de stocker le résultat quelque part. Il leur faut donc préciser trois opérandes dans le résultat : la localisation des deux données à manipuler, et l'endroit où ranger le résultat. Sur les '''architectures à deux adresses''', le résultat d'une instruction est stocké à l'endroit indiqué par la référence du premier opérande : cette donnée sera remplacée par le résultat de l'instruction. Avec cette organisation, les instructions ne précisent que deux opérandes. Mais la gestion des instructions est moins souple, vu qu'un opérande est écrasé. Avec cette organisation, les instructions sont plus courtes. Sur les '''architectures à trois adresses''', on peut préciser le registre de destination du résultat. Ce genre d'architectures permet une meilleure utilisation des registres, mais les instructions deviennent plus longues que sur les architectures à deux adresses.
Les '''architectures LOAD-STORE''' sont identiques aux architectures à registres à un détail près : les instructions arithmétiques et logiques ne peuvent aller chercher leurs données que dans des registres du processeurs. Dit autrement, seules les instructions d'accès mémoire peuvent accéder à la mémoire, les autres instructions n’accédant pas directement à la mémoire. En conséquence, ces instructions ne peuvent prendre que des noms de registres ou des constantes comme opérandes : cela n'autorise que les modes d'adressage immédiat et à registre. Il faut noter aussi que les architectures Load-store sont elles aussi classées en architectures à 2 ou 3 adresses, comme les architectures à registres.
 
[[File:Isreg2reg.png|centre|vignette|Architecture LOAD-STORE.]]
 
===ArchitecturesLes architectures à pile et à file===
 
[[File:Exemple d'une machine à pile qui code ses entiers sur 4 Bytes.png|vignette|Exemple d'une pile/file d'opérandes, chaque opérande étant codée sur 4 Bytes.]]
39 492

modifications