Processeur

Le processeur est la partie centrale d'un ordinateur. C'est lui qui exécute les instructions données par un programme. Les processeur sont tous différents, mais ils ont des caractéristiques communes.

Mais comment ça marche ?

L'instruction

L'instruction est indiquée par un mot machine d'une valeur bien particulière qui va indiquer au processeur ce qu'il doit exécuter. Soit l'instruction est seule, soit l'instruction est suivie d'un argument de taille variable. La taille de l'argument dépend de l'instruction.

Les registres

Tout d'abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d'aller chercher les données nécessaire à l'instruction à exécuter.

Le pointeur d'instruction (PC)

Le pointeur d'instruction indique l'adresse de la prochaine instruction à exécuter. Après l'exécution de l'instruction il avance d'autant de mots que l'instruction occupe. Les instructions les plus élémentaires ne nécessitent qu'un mot alors que des instructions plus complexe en occupent plus.

Il arrive que le pointeur d'instruction soit accompagné d'un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l'ensemble de la mémoire.

Le registre d'état (SR)

Le registre d'état recense les différents drapeaux d'état qui sont altérés en fonction des instructions. Parmi ces drapeaux nous avons:

• La retenue (carry flag)
• Le dépassement (overflow): activé lorsqu'un calcul dépasse la capacité d'un mot machine.
• Le zéro (zero flag): Change d'état en fonction des instructions de comparaison.
• Le signe (S) : activé lorsque le résultat d'une instruction est une valeur négative

L'accumulateur (A)

Il s'agit du registre principal pour les opérations arithmétiques et logique.

Le pointeur de pile (SP)

La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d'appel.

Les index (X, Y)

La valeur en mémoire est récupérée ou stockée à l'emplacement mémoire indiqué en décalant de la valeur de l'index. Nous verrons plus qu'il existe différents adressages indexés.

Les adressages

Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d'adressage. J'ai ajouté des exemples de ce que donne les différents mode d'adressage. Pour cela j'utilise la convention suivante:

• A : accumulateur
• PC : pointeur d'instruction
• Addr : adresse indiquée en opérande de l'instruction
• X : index
• n : opérande direct
• Mem[...] : indique une valeur en mémoire à l'emplacement indiqué.
• s : taille de l'instruction avec ses opérandes.

L'adressage implicite

Certaines instructions comme par exemple l'empilement ou le dépilement n'ont pas besoin de définir une adresse. Dans ce cas elle est implicite

Adressage immédiat

La donnée est un argument de l'instruction.

A <- n

Adressage direct

L'instruction va chercher directement la valeur à l'emplacement mémoire indiqué dans l'instruction.

A <- Mem[Addr]

Adressage absolu

Lors d'instruction de saut on indique l'adresse de destination.

PC <- Addr

Adressage relatif

On indique ici une adresse qui correspond au pointeur d'instruction plus un nombre de mots défini en argument. Ce mode d'adressage est essentiellement utilisé dans instructions de saut conditionnel.

PC <- PC + n + s

A <- Mem[PC + n]

Adressage indirect

L'instruction lit à l'emplacement mémoire indiqué l'adresse où il faut lire la donnée. A <- Mem[Mem[Addr]]

Adressage indexé

L'instruction lit à l'emplacement mémoire en ajoutant la valeur de l'index. Les adressage indexés sont de différentes natures.

L'adressage direct indexé: il s'agit de lire à l'emplacement mémoire indiqué par l'opérande augmenté de la valeur de l'index.

A <- Mem[Addr + X]

L'adressage indirect pré-indexé:

A <- Mem[Mem[Addr + X]]

L'adressage indirect post-indexé:

A <- Mem[Mem[Addr] + X]

Les instructions

Je ne vais pas les détailler ici, parce que d'une part chaque processeur dispose d'un jeu d'instruction plus ou moins étendu et que de toutes façon la liste serait trop longue. Je vais quand même aborder les principales.

Les sauts

Dans la section précédente j'avais évoqué différents types de saut. Il s'agit d'instructions qui manipulent directement le pointeur d'instruction.

Le saut inconditionnel

On indique au processeur l'adresse de la prochaine instruction à exécuter.

JUMP Addr

Le saut avec condition de retour

Avant de réaliser le saut à l'adresse indiquée, l'adresse de l'instruction suivante est poussée en pile. Cette instruction est utilisé pour réaliser des appels de sous-programme.

CALL Addr

Le retour d'appel

L'adresse de l'instruction suivante est dépilée. Elle met fin à l'appel de sous-programme.

RETURN

Il existe des instructions de retour qui indiquent en plus le nombre de mots à dépiler.

RETURN n

Le saut conditionnel

L'adresse indiquée qu'elle soit absolue ou relative ne sera prise en compte qu'en fonction du drapeau d'état testé.

Cela correspond à des instructions du type: IF CarryFlag THEN JUMP Addr IF NOT ZeroFlag THEN JUMP +n

Manipulation de la pile

La plupart des processeurs fonctionnent avec une pile. En plus des instructions lié à l'appel de sous-programme, on peut empiler et dépiler directement. Il existe habituellement une instruction pour chaque registre du processeur.

PUSH A, PULL X

On peut par exemple sauvegarder en pile le registre d'état, réaliser une opération quelconque, puis restaurer le registre d'état depuis la pile.

La lecture de données

La plupart des instructions de lecture affectent la valeur indiquée à l'accumulateur. Il arrive également que les index puissent être également affectés directement.

LOAD A, 50 LOAD X, 00AF80F9

L'écriture de donnée

Il s'agit de l'opération inverse de la précédente. Normalement seul le contenu de l'accumulateur est utilisé

STORE 00AF80F9+X

Les comparaisons

Ce type d'instruction consiste à comparer la valeur de l'accumulateur avec une valeur quelconque. Normalement c'est le drapeau Zéro qui est affecté si les valeurs sont identiques ou non.

COMP A, 10

Les opérations logiques

J'avis déjà évoqué les opérateurs logiques au niveau du bit. Ici, les opérateurs s'appliquent à l'ensemble du mot machine.

Le NON

La valeur de chaque bit est inversé. Chaque 1 devient un zéro et réciproquement.

Exemple: NOT 01101001 -> 10010110

Le OU et le ET

On sert sert du OU pour s'assurer qu'un bit en particulier soit actif, et le ET pour désactiver un bit. On parle ici de masquage.

Par exemple: 00010001 OU 10001000 -> 10011001 11110111 ET 00101111 -> 00100111

Les glissements et les rotations

Les glissements correspondent simplement à un décalage vers la gauche ou vers la droite de tous le bits du mot. Le bit ajouté est toujours à zéro. Le plus enlevé est perdu. Il peut arriver qu'il soit stocké dans la retenue. Ces instructions correspondent en réalité à une multiplication ou une division entière par 2 (deux). Comme cette instructions est beaucoup plus rapide que les instructions arithmétique, les algorithmes qui s'appuie sur le divisions et multiplications par deux sont particulièrement efficaces.

La rotation est un raffinement du glissement en prenant en compte le bit qui sort. Il est alors réintroduit dans le bit ajouté lors du glissement.

Les opérateurs arithmétiques

Les instructions les plus simples sont les opérations d'incrémentation et de décrémentation. Il s'agit d'ajouter ou retirer 1 à la valeur du registre. L'accumulateur et les registres d'index sont concernés.

Ensuite nous avons les additions et les soustractions et puis c'est tout.

Certains processeurs complexes incluent également la multiplication et la division entière.

Les entrées / sorties

En plus d'accéder à la mémoire, le processeur peut émettre ou recevoir des bits par l'intermédiaire des ports d'entrées / sorties. Ceci permet de commander des périphériques comme la carte graphique, le clavier ou le disque dur.

En bref, ceci permet au processeur d'interagir avec le monde extérieur.