Le microprocesseur
Un microprocesseur est composé de trois éléments principaux : Une unité de commande, Une unité
de traitement et Des registres
Ces trois éléments sont reliés entre eux par des bus internes permettant les échanges d’informations
Il existe deux types de registres :
Les registres d'usage général permettent à l'unité de traitement de manipuler des données à
vitesse élevée. Ils sont connectés au bus données interne au microprocesseur
Les registres d'adresses (pointeurs) connectés sur le bus adresses
Unité de commande :
Elle permet de gérer le déroulement des instructions en recherchant l'instruction en
mémoire, en la décodant (car elle est en binaire), en l'exécutant, puis en préparant
l'instruction suivante.
Pour cela, elle est composée de :
Le compteur de programme : C'est un registre qui contient l'adresse de la première
instruction du programme et qui est constamment mis à jour pour stocker l'adresse de
l'instruction à exécuter. Il s'incrémente automatiquement après chaque exécution.
Le registre d'instruction et le décodeur d'instruction : chacune des instructions à exécuter
est rangée dans le registre instruction puis est décodée par le décodeur d’instruction
Elle comprend un bloc logique de commande (ou séquenceur) qui organise
l'exécution des instructions en fonction du rythme de l'horloge, suivant une séquence
d'étapes précises.
L'unité de traitement :
Cœur du microprocesseur, regroupe les circuits responsables de l'exécution
des instructions. Elle inclut l'Unité Arithmétique et Logique (UAL), qui effectue
des opérations logiques (ET, OU, comparaison) et arithmétiques (addition,
soustraction). Le registre d'état, constitué de bits appelés drapeaux, indique
le résultat de la dernière opération de l'UAL (ex. : retenue, signe,
débordement, zéro, parité).
Elle inclut également les accumulateurs, qui sont des registres de travail
utilisés pour stocker un opérande au début d'une opération arithmétique et le
résultat à la fin de l'opération.
Schéma fonctionnel du microprocesseur :
Cycle d’exécution d’une instruction :
Le cycle d'exécution d'une instruction se décompose en trois phases :
1. Recherche de l'instruction à traiter.
2. Décodage de l'instruction et recherche de l'opérande.
3. Exécution de l'instruction.
Le microprocesseur traite uniquement un nombre limité d'instructions, codées en binaire.
Phase 1 : Recherche de l'instruction à traiter
1. Le PC (Compteur du programme) contient l'adresse de l'instruction suivante, qui est
placée sur le bus d'adresses par l'unité de commande, qui émet un ordre de lecture.
2. Après un délai (temps d'accès à la mémoire), le contenu de la case mémoire
sélectionnée est disponible sur le bus des données.
3. L'instruction est ensuite stockée dans le registre instruction du processeur
Phase 2 : Décodage de l’instruction et recherche de l'opérande
Le registre d'instruction contient le premier mot de l'instruction, qui inclut le code
opératoire (définissant l'opération à effectuer) et le nombre de mots de l'instruction.
1. L'unité de commande transforme l'instruction en une série de commandes
élémentaires (micro-programme) nécessaires pour son traitement.
2. Si l'instruction nécessite une donnée de la mémoire, l'unité de commande la
récupère via le bus de données.
3. L’opérande est ensuite stocké dans un registre.
Phase 3 : Exécution de l’instruction
1. Le micro-programme correspondant à l'instruction est exécuté.
2. Les drapeaux (registres d'état) sont mis à jour en fonction du résultat de l'exécution.
3. L'unité de commande met à jour le PC pour pointer vers l'instruction suivante.
Types d’instructions
Les instructions des microprocesseurs peuvent être classées en quatre groupes :
1. Opérations de transfert de données : charger ou sauvegarder en mémoire, transferts
entre registres, etc.
2. Opérations arithmétiques : addition, soustraction, multiplication, division.
3. Opérations logiques : ET, OU, NON, NAND, comparaison, test, etc.
4. Opérations de contrôle de séquence : branchement, test, etc.
Codage des instructions
Les instructions et leurs opérandes sont stockés en mémoire principale.
La taille d'une instruction (en bits) dépend du type d'instruction et de l'opérande.
Chaque instruction est codée sur un nombre entier d'octets pour faciliter son
décodage par le processeur.
Une instruction se compose de deux champs :
1. Le code instruction, qui indique au processeur quelle opération réaliser.
2. Le champ opérande, qui contient la donnée ou la référence (adresse) de la
donnée en mémoire.
Exemple ;
Code instruction Code opérande
1001 0011 0011 1110
Mode d’adressage
Un mode d'adressage définit la méthode d'accès du microprocesseur à l'opérande. Les
principaux modes d'adressage sont :
L'adressage de registre : La donnée est traitée directement dans un registre.
L'adressage immédiat : La valeur de la donnée est définie directement dans
l'instruction.
L'adressage direct : La donnée est traitée en mémoire, à une adresse spécifique.
En fonction du mode d'adressage, une instruction peut être codée sur un ou plusieurs
octets.
Temps d’exécution
Chaque instruction nécessite un certain nombre de cycles d'horloge pour être exécutée. Le nombre
de cycles dépend de la complexité de l'instruction et du mode d'adressage (par exemple, l'accès à la
mémoire principale prend plus de temps que l'accès à un registre du processeur). La durée d'un cycle
d'horloge est déterminée par la fréquence d'horloge du séquenceur.
Jeu d’instructions
La première étape de la conception d'un microprocesseur consiste à définir son jeu
d'instructions, qui décrit l'ensemble des opérations élémentaires que le microprocesseur
pourra exécuter. Ce jeu d'instructions influence l'architecture du microprocesseur,
notamment celle du séquenceur.
Il existe deux grandes familles de jeux d'instructions, conduisant à deux modèles
d'architecture des microprocesseurs :
1. CISC (Complex Instruction Set Computer) : Architecture à jeu d'instructions
complexe.
2. RISC (Reduced Instruction Set Computer) : Architecture à jeu d'instructions réduit.
Architecture CISC (Complex Instruction Set Computer) :
Dans le passé, la mémoire était beaucoup plus lente que le processeur, et il fallait donc
minimiser les accès mémoire pour améliorer les performances. L'idée derrière l'architecture
CISC était de réduire le nombre d'instructions nécessaires pour réaliser une tâche en offrant
des instructions complexes, chacune accomplissant une tâche complète.
Jeu d'instructions complexe : Plus les tâches sont diversifiées, plus le nombre
d'instructions dans le jeu est important, rendant ce jeu d'instructions très complexe.
Architecture plus complexe : Un jeu d'instructions complexe entraîne une
architecture de processeur plus compliquée, avec un décodeur d'instructions
sophistiqué.
Exécution de tâches : Une machine CISC exécute généralement un petit nombre
d'instructions pour une tâche donnée, mais chaque instruction prend plus de temps
(plus de cycles d'horloge).
Architecture RISC (Reduced Instruction Set Computer)
Les études ont montré que les programmes compilés utilisent principalement quelques
instructions simples, comme les affectations, additions et multiplications. En fait, 80% des
programmes écrits en langages de haut niveau se contentent de 20% des instructions
disponibles sur un microprocesseur.
L'idée derrière l'architecture RISC est donc de réduire le jeu d'instructions, en se concentrant
sur les opérations les plus courantes, et d'améliorer leur vitesse d'exécution.
Instructions réduites : Le jeu d'instructions est limité, avec des instructions simples
qui s'exécutent en un seul cycle d'horloge.
Accès mémoire simplifiés : Les accès à la mémoire sont limités à deux instructions
principales : Lire/Écrire ou Load/Store.
Instructions complexes : Les instructions plus complexes sont réalisées en combinant
plusieurs instructions élémentaires.
Cette approche permet de simplifier le processeur et d'augmenter la vitesse
d'exécution en réduisant la complexité du décodeur et des opérations.
Comparaison entre RISC et CISC
Langage de programmation
Langage machine : Le langage natif du microprocesseur, difficile à maîtriser car
chaque instruction est codée en bits spécifiques.
Langage assembleur : Plus facile que le langage machine, il utilise des mnémoniques
pour représenter des opérations simples comme le transfert de données ou des
opérations arithmétiques/logiques. Chaque instruction assembleur correspond à un
code machine spécifique et varie selon le microprocesseur.
Langages de haut niveau : Des langages comme C, Java, ou Python, conçus pour
faciliter la programmation en permettant d'écrire des algorithmes dans un format
plus accessible. Chaque instruction en langage de haut niveau se traduit par plusieurs
instructions en assembleur.
Compilation : Un programme en langage de haut niveau doit être compilé, traduit en
assembleur, puis assemblé pour générer le code machine compréhensible par le
microprocesseur. Cela se fait à l'aide de compilateurs et assembleurs spécialisés.
* :« 68HC11 » est le modèle du microprocesseur étudié dans cet exemple
Performances d’un microprocesseur
On peut caractériser la puissance d’un microprocesseur par le nombre d’instructions traitées par
seconde
Pour cela, on définit :
Le CPI (Cycle Par Instruction) qui représente le nombre moyen de cycles d’horloge nécessaire
pour l’exécution d’une instruction pour un microprocesseur donné
Le MIPS (Millions d'Instructions Par Seconde) qui représente la puissance de traitement du
microprocesseur
𝑴𝑰𝑷𝑺 = 𝑭𝑯 /𝑪𝑷I
Avec 𝑭𝑯 : Fréquence de l’horloge du microprocesseur
Pour augmenter les performances d’un microprocesseur, on peut donc soit augmenter la
fréquence d'horloge (limitation matérielle), soit diminuer le CPI (choix d'un jeu d'instruction
adapté)