MIPS ISA: L’Architecture du Jeu d’Instruction

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.

Interface entre logiciel et matériel : l’architecture du jeu d’instruction

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.

Problématique de l’architecture du jeu d’instruction

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 :

• L’efficacité du compilateur, qui traduit le code source en instructions machine.
• La complexité du matériel, qui doit exécuter ces instructions.
• La vitesse d’exécution globale du système.

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.

Les deux grandes familles de jeux d’instructions : CISC et RISC

Il existe deux grandes familles d’architectures de jeu d’instruction :

• CISC (Complex Instruction Set Computer) : Cette architecture propose un grand nombre d’instructions complexes, capables d’exécuter des tâches élaborées en une seule instruction. Les instructions sont souvent de formats variables, nécessitant un décodeur complexe basé sur du microcode. Le matériel est plus compliqué, mais le compilateur est simplifié. Les instructions peuvent accéder directement à la mémoire et il existe de nombreux modes d’adressage. Exemple : processeur 8086.
• RISC (Reduced Instruction Set Computer) : Cette architecture privilégie un jeu d’instructions réduit et simple, avec des instructions de format fixe, exécutées en un seul cycle. Le décodeur est simple, le matériel est allégé, mais le compilateur doit être plus sophistiqué. Seules les instructions de chargement (load) et de rangement (store) accèdent à la mémoire, et il y a peu de modes d’adressage. Exemple : processeur MIPS.

Comparaison entre architectures RISC et CISC

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

Performances des machines

Les performances d’un ordinateur dépendent de trois facteurs clés :

• Le nombre d’instructions nécessaires pour exécuter un programme.
• Le temps de cycle d’horloge (durée d’un cycle).
• Le nombre de cycles d’horloge par instruction.

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.

Classification des jeux d’instruction selon l’accès aux opérandes

On distingue plusieurs types de machines selon la manière dont l’unité arithmétique obtient ses opérandes :

Machines à accumulateur

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

Machines à pile

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

Machines à registres généraux

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

Machines à chargement/rangement (Load/Store)

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

Historique et justification des architectures CISC et RISC

À 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.

Exemple de comparaison entre instructions CISC et RISC

Pour une opération d’addition avec une constante :

• Sur un processeur 8086 (CISC) : Add [BX], 300
• Sur un processeur MIPS (RISC) :

Lw $1, 0($3)
Addi $2, $1, 300
Sw $2, 0($3)

Points clés

• L’architecture du jeu d’instruction (ISA) est l’interface entre logiciel bas niveau et matériel.
• Le jeu d’instruction résulte d’un compromis entre efficacité du compilateur, complexité matérielle et vitesse.
• Deux grandes familles d’architectures : CISC (instructions complexes, matériel complexe, compilateur simple) et RISC (instructions simples, matériel simple, compilateur complexe).
• Les performances dépendent du nombre d’instructions, du temps de cycle et du nombre de cycles par instruction.
• Classification des machines selon l’accès aux opérandes : accumulateur, pile, registres généraux, load/store.
• L’architecture RISC est née de l’observation que peu d’instructions sont majoritairement utilisées dans les programmes.
• Les architectures RISC nécessitent des compilateurs avancés pour traduire les instructions complexes en séquences d’instructions élémentaires.