Modèle d’architecture de Von Neumann

Il y a quatre éléments :

L’unité arithmétique et logique : Elle effectue les opérations de base.

Elle est compsée de registres de données et d'un registre spécial, l'accumulateur ou vont s'effectuer les calculs.

Il y a des circuits electroniques pou effectuer le opérations arithmétiques (addition, ...) et logique ( et, ou, complément à un,...) des comparaisons (egalité, supérieur, ...) et opérations sur les bitss( décalage, rotation, ... )

L’unité de commande : elle est chargè du sequençage ou du découpage des opérations.

La mémoire : Elle contient les données, les programmes et indique à l’UC quelles opérations effectuer.

Les entrées et sorties : assurent la communication avec l’extérieur.

Une horloge permet de synchroniser le fonctionnement. Les différents éléments échangent des informations à l’aide de bus. 

 

Limitation du système:

Aujourd'hui la différence de vitesse  entre les microprocesseurs et la mémoire faite que les microprocecceurs passe leur temp a attendre des données, d'ou l'idée d'utiliser de la mémoir cache (entre la mémoire RAM et le microprocesseur )

memoire	temps d'accès	débit	capacité
registres	1ns		Kio
mémoire cache	2-3 ns		Mio
mémoire vive	5-60 ns	1-20 Gio/s	Gio
disque durs	3-20 ms	10-320 Mio/s	Tio
DVD	140 ms	2-22 Mio/s	4.5-17 Gio

 

Pour plus de précision : cliquer ici

Les instructions d’un programme de haut niveau sont traduites pour être comprises par la machine.

Utilisons le module dis de Python :

import dis

dis.dis('x=1;x=x+2')

On obtient :

1 0 LOAD_CONST 0 (1)

3 STORE_NAME 0 (x)

6 LOAD_NAME 0 (x)

9 LOAD_CONST 1 (2)

12 BINARY_ADD

13 STORE_NAME 0 (x)

16 LOAD_CONST 2 (None)

19 RETURN_VALUE

 

Cela signifie que :

→ Le nombre 1 est copié dans le registre

→ Le contenu du registre est copié dans la mémoire à la case adressée par x

→ la valeur de x est copié dans le registre

→ le nombre 2 est copié dans le registre

→ l’addition des deux est effectuée

→ le résultat est copié dans la mémoire à la case adressée par x

→ la valeur None est copiée dans le registre

→ elle est renvoyée

ce module permet de comprendre ce qui se passe au cœur de la machine :

L’UAL ne sait effectuer de base que des opérations de base, il faut donc séquencer chaque action.

Le langage assembleur qui est de bas niveau et très proche de la machine :

 

MOV R0, #4

STR R0,30

MOV R0, #8

STR R0,75

LDR R0,30

CMP R0, #10

BNE else

MOV R0, #9

STR R0,75

B endif

else:

LDR R0,30

ADD R0, R0,#1

STR R0,30

endif:

MOV R0, #6

STR R0,23

HALT

 

On peut utiliser ce simulateur en le programmant en assembleur.

MOV R1,#23	Place le nombre 23 dans le registe R1
STR R1,125	Place la valeur R1 dans la mémoire d’adresse 125
LDR R1,78	Place dans R1 ce qu’il y a dans la mémoire à l’adresse 78
ADD R1,R0,#128	Additionne R0 et le nombre 128 et place le résultat dans R1
SUB R0,R1,R2	La valeur de R2-R1 est stockè dans R0
B 45 (Ou B monLabel puis monLabel : … )	La prochaine séquence est à l’adresse 45
CMP R0,#23 BNE 78	Si R0 différent de 23, la prochaine instruction est en 78
CMP R0,#23 BEQ 78	Si R0 est égal à 23, la prochaine instruction est en 78
CMP R0,#23 BGT 78	Si R0 est plus grande que 23, la prochaine instruction est en 78
CMP R0,#23 BLT 78	Si R0 est plus petite que 23, la prochaine instruction est en 78
HALT	Fin du programme.

En python le programme précédent devient :

x = 4
y = 8
if x == 10:
	y = 9
else :
	x=x+1
z=6

Remarque : Le langage x86 a huit registres :eax,ebx,ecx,edx,esi,edi,esp, et ebp

il y a aussi les registre cs pour le segment de code, eip pour le pointeur d'instruction, ds pour le segment de donnée,ss pour le segment de pile et esp pour le sommet de la pile.

architechture multiprocesseurs.

A force d'augmenter la fréquences des processeurs (ce qui permettait un plus grand nombre d'opération par seconde), les fabriquants (AMD, Intel) se sont heurtés à un obstacle : les processeurs chuffaient trop.

Ils ont alors choisit de mutltiplier les coeurs . 

Dans un microprocesseur, un coeur est principalement composé : d'une UAL, de registres (R0, R1...) et d'une unité de commande, un coeur est donc capable d'exécuter des programmes de façon autonome.

Pour schématiser, on peut imaginer qu'un coeur s'ocupe d'une tache pendant qu'un autre s'ocupe d'une autre.

Ce n'est pas toujours aussi simple, cela dépend aussi de la manière dont sont conçu les applications, mais aussi du système d'exploitation, de la mémoire qu'il faut partager entre les coeurs, ...