MIPS ISA: L’Architecture du Jeu d’Instruction
MIPS ISA: L’Architecture du Jeu d’Instruction
Computer Architecture · notes
Fiche de révisionRésumé
Rédigée à partir de ce document, puis vérifiée avant publication.
Cette conférence porte sur l'architecture du jeu d'instruction (ISA) dans le contexte des microprocesseurs, en particulier sur l'architecture MIPS. Elle s'inscrit dans un cours d'informatique traitant des relations entre logiciel bas niveau et matériel, ainsi que des compromis dans la conception des systèmes informatiques.
L'architecture du jeu d'instruction (ISA) constitue l'interface clé entre les différents niveaux d'abstraction dans un système informatique. Elle relie le logiciel de bas niveau, notamment le langage machine, au matériel physique. Cette interface permet de comprendre comment les programmes écrits dans des langages de haut niveau sont traduits et exécutés par le processeur.
Le processus de traduction passe par plusieurs étapes : un programme en langage de haut niveau (Pascal, C, C++) est compilé en langage assembleur, puis assemblé en langage machine, et enfin chargé en mémoire pour être exécuté par le processeur. Cette hiérarchie de traduction est essentielle pour la communication entre logiciel et matériel.
La conception d’un système informatique nécessite une collaboration étroite entre la conception du logiciel et celle du matériel, un processus appelé co-design. Le jeu d’instruction doit être conçu en tenant compte de nombreux compromis :
Le jeu d’instruction est donc le résultat d’un équilibre entre ces facteurs, influençant directement la performance et le coût du système.
Il existe deux grandes familles d’architectures de jeu d’instruction :
| Caractéristique | Architecture RISC | Architecture CISC |
|---|---|---|
| Complexité des instructions | Instructions simples, un seul cycle | Instructions complexes, plusieurs cycles |
| Format des instructions | Format fixe | Format variable |
| Décodeur | Simple, câblé | Complexe, microcode |
| Nombre de registres | Beaucoup | Peu |
| Accès à la mémoire | Seules les instructions LOAD et STORE | Toutes les instructions peuvent accéder à la mémoire |
| Modes d’adressage | Peu nombreux | Beaucoup |
| Complexité du compilateur | Complexe | Simple |
Les performances d’un ordinateur dépendent de trois facteurs clés :
Le compilateur et l’architecture du jeu d’instruction déterminent le nombre d’instructions. La mise en œuvre matérielle influence le temps de cycle et le nombre de cycles par instruction.
On distingue plusieurs types de machines selon la manière dont l’unité arithmétique obtient ses opérandes :
Ces machines possèdent un seul registre appelé accumulateur. Les opérations se font entre une case mémoire et l’accumulateur, et le résultat est stocké dans l’accumulateur. Exemple : microprocesseur 6502.
Séquence de code pour C = A + B :
Load Acc, A Add Acc, B Store C, Acc
Ces machines n’ont pas de registres explicites. Les opérations utilisent la pile pour prendre les opérandes et y stocker le résultat. Cette architecture est peu efficace et rarement utilisée. Exemple : calculatrice HP.
Séquence de code pour C = A + B :
Pop A Pop B Add Push C
Ces machines disposent de plusieurs registres pouvant tous jouer le rôle d’accumulateur. Le résultat peut être stocké dans un registre ou directement en mémoire. Exemple : microprocesseur 8086.
Séquence de code pour C = A + B :
Load r1, A Add r1, B Store C, r1
Similaires aux machines à registres généraux, mais seules les instructions de chargement (load) et de rangement (store) accèdent à la mémoire. Toutes les opérations arithmétiques se font entre registres. Exemple : microprocesseur MIPS.
Séquence de code pour C = A + B :
Load r1, A Load r2, B Add r3, r1, r2 Store C, r3
À l’origine, les architectures CISC étaient privilégiées car la mémoire était beaucoup plus lente que le processeur. Il était donc plus efficace de soumettre au processeur des instructions complexes, réduisant le nombre d’accès mémoire.
Dans les années 1970, des études ont montré que 80 % des traitements réalisés par les programmes utilisaient seulement 20 % des instructions du microprocesseur. Cela a conduit à l’idée de réduire le jeu d’instructions, donnant naissance à l’architecture RISC.
Les instructions complexes dans une architecture RISC doivent être réalisées par des séquences d’instructions élémentaires, ce qui nécessite un compilateur très évolué, notamment pour les langages de haut niveau. Exemples d’architectures RISC : MIPS, SPARC.
Pour une opération d’addition avec une constante :
Add [BX], 300Lw $1, 0($3) Addi $2, $1, 300 Sw $2, 0($3)