Le rôle fondamental de la plupart des unités centrales de traitement, indépendamment de la forme physique qu'elles prennent, est d'exécuter une série d'instructions stockées appelées "programme".
Les instructions (parfois décomposées en micro instructions) et les données transmises au processeur sont exprimées en mots binaires (code machine). Elles sont généralement stockées dans la mémoire. Le séquenceur ordonne la lecture du contenu de la mémoire et la constitution des mots présentées à l'ALU qui les interprète. L’ensemble des instructions et des données constitue un programme.
Le langage le plus proche du code machine tout en restant lisible par des humains est le langage d’assemblage, aussi appelé langage assembleur (forme francisée du mot anglais « assembler »). Toutefois, l’informatique a développé toute une série de langages, dits de haut niveau (comme le BASIC, Pascal, C, C++, Fortran, Ada, etc), destinés à simplifier l’écriture des programmes.
Les opérations décrites ici sont conformes à l'architecture de von Neumann. Le programme est représenté par une série d'instructions qui réalisent des opérations en liaison avec la mémoire vive de l'ordinateur. Il y a quatre étapes que presque toutes les architectures von Neumann utilisent :
- FETCH (Recherche de l'instruction) ;
- DECODE (Décodage de l'instruction : opérations et opérandes) ;
- EXECUTE (Exécution des opérations) ;
- WRITEBACK (Ecriture du résultat).
La première étape, FETCH (recherche), consiste à rechercher une instruction dans la mémoire vive de l'ordinateur. L'emplacement dans la mémoire est déterminé par le compteur de programme (PC), qui stocke l'adresse de la prochaine instruction dans la mémoire de programme. Après qu'une instruction ait été recherchée, le PC est incrémenté par la longueur du mot d'instruction. Dans le cas de mot de longueur constante simple, c'est toujours le même nombre. Par exemple, un mot de 32 bits de longueur constante qui emploie des mots de 8 bits de mémoire incrémenterait toujours le PC par 4 (excepté dans le cas des sauts). Le jeu d'instructions qui emploie des instructions de longueurs variables comme l'x86, incrémentent le PC par le nombre de mots de mémoire correspondant à la dernière longueur d'instruction. En outre, noter que dans des unités centrales de traitement plus complexes, l'incrémentation du PC ne se produit pas nécessairement à la fin de l'exécution d'instruction. C'est particulièrement le cas dans des architectures fortement parallélisées et superscalaires. Souvent, la recherche de l'instruction doit est opérée dans des mémoires lentes, ralentissant l'unité centrale de traitement qui attend l'instruction. Cette question est en grande partie résolue dans les processeurs modernes par l'utilisation de caches et d'architectures pipelines.
L'instruction que le processeur recherche en mémoire est utilisée pour déterminer ce que le CPU doit faire. Dans l'étape DECODE (décodage), l'instruction est découpée en plusieurs parties telles qu'elles puissent être utilisées par d'autres parties du processeur. La façon dont la valeur de l'instruction est interprétée est définie par le jeu d'instructions (ISA) du processeur. Souvent, une partie d'une instruction, appelée opcode (code d'opération), indique quelle opération est à faire, par exemple une addition. Les parties restantes de l'instruction comportent habituellement les autres informations nécessaires à l'exécution de l'instruction comme par exemples les opérandes de l'addition. Ces opérandes peuvent prendre une valeur constante, appelée valeur immédiate, ou bien contenir l'emplacement où retrouver (dans un registre ou une adresse mémoire) la valeur de l'opérande, suivant le mode d'adressage utilisé. Dans les conceptions anciennes, les parties du processeur responsables du décodage étaient fixes et non modifiables car elles étaient codées dans les circuits. Dans les processeurs plus récents, un microprogramme est souvent utilisé pour traduire les instructions en différents ordres. Ce microprogramme est parfois modifiable pour changer la façon dont le CPU décode les instructions, même après sa fabrication.
Après les étapes de recherche et de décodage arrive l'étape EXECUTE (exécution) de l'instruction. Au cours de cette étape, différentes parties du processeur sont mises en relation pour réaliser l'opération souhaitée. Par exemple, pour une addition, l'unité arithmétique et logique (ALU) sera connectée à des entrées et des sorties. Les entrées présentent les nombres à additionner et les sorties contiennent la somme finale. L'ALU contient la circuiterie pour réaliser des opérations d'arithmétique et de logique simples sur les entrées (addition, opération sur les bits). Si le résultat d'une addition est trop grand pour être codé par le processeur, un signal de débordement est positionné dans un registre d'état (voir ci-dessous le chapitre sur le codage des nombres).
La dernière étape WRITEBACK (écriture du résultat), écrit tout simplement les résultats de l'étape d'exécution en mémoire. Très souvent, les résultats sont écrits dans un registre interne au processeur pour bénéficier de temps d'accès très courts pour les instructions suivantes. Dans d'autres cas, les résultats sont écrits plus lentement dans des mémoires RAM, donc à moindre coût et acceptant des codages de nombres plus grands.
Certains types d'instructions manipulent le compteur de programme plutôt que de produire directement des données de résultat. Ces instructions sont appelées des sauts (jumps) et permettent de réaliser des boucles (loops), des programmes à exécution conditionnelle ou des fonctions (sous-programmes) dans des programmes. Beaucoup d'instructions servent aussi à changer l'état de drapeaux (flags) dans un registre d'état. Ces états peuvent être utilisés pour conditionner le comportement d'un programme, puisqu'ils indiquent souvent la fin d'exécution de différentes opérations. Par exemple, une instruction de comparaison entre deux nombres va positionner un drapeau dans un registre d'état suivant le résultat de la comparaison. Ce drapeau peut alors être réutilisé par une instruction de saut pour poursuivre le déroulement du programme.
Après l'exécution de l'instruction et l'écriture des résultats, tout le processus se répète, le prochain cycle d'instruction recherche la séquence d'instruction suivante puisque le compteur de programme avait été incrémenté. Si l'instruction précédente était un saut, c'est l'adresse de destination du saut qui est enregistrée dans le compteur de programme. Dans des processeurs plus complexes, plusieurs instructions peuvent être recherchées, décodées et exécutées simultanément, on parle alors d'architecture pipeline, aujourd'hui communément utilisée dans les équipements électroniques.
Aucun commentaire:
Enregistrer un commentaire