Processeur - Historique des versions

Guillaume le 1 septembre 2022 à 15:22

2022-09-01T15:22:08Z

← Version précédente		Version du 1 septembre 2022 à 15:22
Ligne 139 :		Ligne 139 :
	STORE 00AF80F9+X		STORE 00AF80F9+X

	=== Les comparaisons ====		=== 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.		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.

Guillaume : Ajout des entrées / sorties

2022-09-01T15:21:38Z

Ajout des entrées / sorties

← Version précédente		Version du 1 septembre 2022 à 15:21
Ligne 172 :		Ligne 172 :

	Certains processeurs complexes incluent également la multiplication et la division entière.		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.

Guillaume le 1 septembre 2022 à 15:10

2022-09-01T15:10:26Z

← Version précédente		Version du 1 septembre 2022 à 15:10
Ligne 91 :		Ligne 91 :
	Je vais quand même aborder les principales.		Je vais quand même aborder les principales.

	=== Les sauts ==		=== 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.		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.

Guillaume le 1 septembre 2022 à 15:09

2022-09-01T15:09:48Z

← Version précédente		Version du 1 septembre 2022 à 15:09
Ligne 3 :		Ligne 3 :

	Mais comment ça marche ?		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 ==		== Les registres ==
Ligne 18 :		Ligne 21 :
	* Le dépassement (overflow): activé lorsqu'un calcul dépasse la capacité d'un mot machine.		* 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 zéro (zero flag): Change d'état en fonction des instructions de comparaison.
	* Le ~~négatif~~ : activé lorsque le résultat d'une instruction est une valeur négative		* Le signe (S) : activé lorsque le résultat d'une instruction est une valeur négative

	=== L'accumulateur (A) ===		=== L'accumulateur (A) ===
Ligne 83 :		Ligne 86 :

	A <- Mem[Mem[Addr] + X]		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.

Guillaume : Page créée avec « 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… »

2022-09-01T13:53:42Z

Page créée avec « 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… »

Nouvelle page

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 ?

== 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 négatif : 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]