1 - ARCHITECTURE de VON NEUNAM

1.1 Bref historique

En 1801, Joseph Marie Jacquard conçoit un métier à tisser mécanique programmable avec cartes perforées.

En 1834, pendant le développement d’une machine à calculer destinée au calcul et à l’impression de tables mathématiques (la machine à différences), Charles Babbage eut l’idée d’y incorporer des cartes perforées du métier Jacquard, dont la lecture séquentielle donnerait des instructions et des données à sa machine. Il imagina, ainsi, l’ancêtre mécanique des ordinateurs électroniques d’aujourd’hui. Il n’acheva jamais sa machine analytique, faute de moyens financiers suffisants. Mais, il fut le premier à énoncer le principe d’un ordinateur.

Ada Lovelace, qui travailla avec Charles Babbage, écrivit le premier véritable programme informatique de l’histoire. Son portrait figure d’ailleurs sur les hologrammes des produits Microsoft.

1.2 Architecture de référence

Un siècle plus tard, l’architecture générale des ordinateurs a été imaginée par John Von Neumann, mathématicien et physicien américano-hongrois en 1945.

L’architecture dite de "Von Neumann" décompose l’ordinateur en 5 parties distinctes :

• l’unité arithmétique et logique (UAL ou ALU en anglais) ou unité de traitement : son rôle est d’effectuer les opérations de base (calculs et tests logiques);
• l’unité de contrôle, chargée du « séquençage » des opérations. C’est le chef d’orchestre, celui qui positionne les différentes étapes d’un programme les unes après les autres;
• la mémoire qui contient à la fois les données à traiter et le programme les traitera. Sachant que traiter des données n’est rien d’autre que d’indiquer à l’unité de contrôle quels sont les calculs à faire sur ces données. La mémoire se divise entre :
  • mémoire volatile (programmes et données en cours de fonctionnement) et
  • mémoire permanente (programmes et données de base de la machine) ;
• les dispositifs de sortie, qui permettent de communiquer avec le monde extérieur à la machine (les humains !).
• les dispositifs d’entrée, qui permettent de recevoir des informations venant du monde extérieur à la machine (les humains !).

On trouve ci-dessous une représentation en 4 blocs avec regroupement des entrée et des sorties.

On note surtout que l’unité de controle et l’unité arithmétique et logique sont regroupées dans un bloc appelé "Central Processing Unit" (CPU) que l’on nomme en français "processeur" ou "micro-processeur" ou encore "puce" du faite de sa taille réduite.

Dans le diagrame ci-dessous, le bloc vert représente l’ordinateur. Les périphériques d’entrée (clavier, souris, camera, scanner…) et les périphériques de sortie (écran, enceintes, imprimante…) ne sont pas considérés comme inclu dans l’ordinateur mais extérieur à celui-ci.

Le diagramme suivant apporte un niveau de détail supplémentaire en ajoutant les "registres" qui sont des cases mémoire peu nombreuses, extrèmement rapide et très proche de la zone de l’unité arithmétique et logique.

D’autres diagrammes comme ci-dessous considère que les registres (ici seul le registre “accumulateur” est présenté) sont incluts dirrectement dans l’UAL (ALU en anglais).

Il existe de nombreuses représentations de l’Architectre de Von Neumann. Toutes sont en général correcte. Ce qui compte c’est de comprendre les liens entre elles et la logique qu’elle présentent.

1.3 L’Unité Arithmétique et Logique - UAL

Imaginons que nous programmions notre calculatrice pour calculer f(4) connaissant f(x) = 2x + 5 en utilisant un pseudo langage machine faisant appel à maximum quatre variables M, N, O et P ainsi que les quatre opérations arithmétiques élémentaires, à savoir :

M <- 2
N <- 4
O <- M x N
M <- 5
P <- O + M

L’unité arithmétique et logique est le cœur de l’ordinateur. On la représente habituellement par ce schéma (en forme de V). Un “V” c’est presque un “cœur” non ?

• A et B sont les opérandes (les entrées)
• R est le Résultat
• F est l’opérateur (opération ou Fonction à effectuer)
• D est un Drapeau indiquant un résultat secondaire de la fonction (signe, erreur, etc.)

Dans l’exercice précédant nous avons utilisé des variables M, N, O et P pour stocker les résultats intermédiaires des opérations à effectuer.

En réalité, quand on “programme” une UAL, nous devons utiliser les variables A, B, R, F et D de celle-ci.

Ce qui donne pour calculer f(4) connaissant f(x) = 2x + 5 :

A <- 2
B <- 4
F <- "x"
A <- R
B <- 5
F <- "+"
P <- R

1.3 La mémoire

1.3.1 Un grand tableau

La mémoire est un tableau dans lequel seront stockés aussi bien les variables que les programmes. Chaque cellule de ce tableau possède une adresse X. Il existe plusieurs façons de noter les valeurs : M[X], X pour une adresse (et $X pour une valeur ou #X), etc.

Exemple :

Donc :

• si X est égal à 3 alors M[X] vaut e, et
• si X vaut 8 alors M[X] vaut B<-4.

On peut donc parcourir toutes les cases de la mémoire en augmentant la valeur de X de 1 (X <- X + 1) et en lisant chaque case mémoire (M[X]) à chaque tour, à chaque “clic” d’horloge.

Voici un exemple de contenu stocké dans une mémoire de 256 cases numérotées (on dit “adressées”) de 0x00 à 0xFF. Il est difficile, à priori de distinguer les valeurs qui sont des nombre ou caractères à traiter et les bouts de programme… Normal tout n’est que binaire dans l’ordinateur !

On voit que :

• si l’adresse est égale à 0x03 alors M[0x03] vaut 0010 0100 c’est à dire 0x24, et
• si l’adresse est égale 0xFE alors M[0xFE] vaut 1101 1110, c’est à dire 0xDE.

1.4 Le processeur

Le processeur (CPU) est constitué :

• d’une unité arirhmétique et logique (ALU) et
• d’une unité de contrôle (CU).

C’est cette dernière qui donne les ordres à toutes les autres parties de l’ordinateur. C’est un peu l’aiguillage des trains dans une gare. Les petits trains transportant des valeurs entre la mémoire et l’UAL et inversement.

Le processeur possède principalement quatre registres :

• Compteur Programme (PC) : appelé aussi compteur ordinal, il contient l’adresse de la prochaine instruction à exécuter (le fameux X de M[X] vu plus haut ;-);
• le Registre d’Instruction (IR): il contient l’instruction en cours (le fameux M[X]);
• l’Accumulateur (ACC) : il chargé de stocker des opérandes intermédiaires (opérande : argument)
• le Code Opération (OP) : il définit ce que doit réaliser l’UAL comme opération

On peut résumer son fonctionnement par l’algorithme (ou pseudo code) suivant :

Répéter indéfiniment :
	IR  ← M[PC]
	PC  ← PC + 1
	ACC ← OP(A, B)
Fin du répéter 

Explications :

• A l’adresse désignée par PC se trouve l’instruction à réaliser. Elle est chargée (stockée) dans IR
• PC est incrémenté (augmenté) de 1
• L’opération à réaliser (chargée) dans IR est exécutée (réalisée) et sont résultat est stocké dans ACC.
• En cas d’instruction conditionnelle, l’adresse du saut à effectuer dans la mémoire est enregistrée dans PC

Il existe plusieurs langages assembleurs. Il faut être capable de s’adapter d’un langage machine à l’autre. Mais il n’est pas demandé d’apprendre les instruction par coeur !!

En langage assembleur, on peut rencontrer des calculs simples (addition, soustraction, multiplication), des affectations (placer telle valeur de la mémoire vive dans tel registre et vice versa) et enfin des instructions de saut qui permettent de coder des instructions conditionnelles par exemple.

Ainsi, il y a trois possibilités pour accéder à un opérande (valeur sur laquelle va être opérée une opération) :

• Il est directement saisi
• Il est dans un registre : il faut alors indiquer le nom de ce registre
• Il est dans la mémoire vive : il faut indiquer son adresse.

Exemple :
On imagine un ordinateur constitué d’une mémoire centrale et d’un jeu d’instructions.

Mémoire : tableau de 32 cellules. Chaque cellule constituée d’un octet.
Instructions : code opération sur 3 bits et une partie adresse sur 5 bits

Voici le tableau d’instructions :

Comme nous l’avons expliqué plus haut, la mémoire contient aussi bien les données que le programme. Dans ce cas, on considèrera que le programme commence à l’adresse 8 et que les adresses 0 à 7 sont réservées au stockage des données (ce n’est pas une règle et peut être organisé autrement pour un autre programme.)

Voici le contenu de la mémoire au démarrage du programme :

31      # variable M[0]
42       # variable M[1]
	





LD 0    # ACC <- M[0]
SUB 1   # ACC ← ACC - M[1]
JMPP 13 # Le compte ordinal CO <- 13 si ACC >0
JMPN 16 # Le compte ordinal CO <- 16 si ACC <0
JMPZ 19 # Le compte ordinal CO <- 19 si ACC = 0 
LD 0    # ACC <- M[0]
STO 2   # M[2] <- ACC
END     # Fin du programme
LD 1    # ACC <- M[1]
STO 2   # M[2] <- ACC
END     # Fin du programme
STO 2   # M[2] <- ACC
END     # Fin du programme

31      # variable M[0]
42      # variable M[1]
	





LD 0    # ACC <- M[0]
SUB 1   # ACC ← ACC - M[1]
JMPP 17 # Le compte ordinal CO <- 17 si ACC >0
JMPN 20 # Le compte ordinal CO <- 20 si ACC <0
JMPZ 13 # Le compte ordinal CO <- 13 si ACC = 0 (INUTILE)
LD 0    # ACC <- M[0] (INUTILE)
SUB 1   # ACC ← ACC - M[0] (INUTILE)
STO 2   # M[2] <- ACC
END     # Fin du programme
LD 0    # ACC <- M[0]
STO 2   # M[2] <- ACC
END     # Fin du programme
LD 1    # ACC <- M[1]
STO 2   # M[2] <- ACC
END     # Fin du programme