LE MICRO-PROCESSEUR :

1 – Architecture interne du microprocesseur :

1 – 1 – Equivalences :

La " largeur" d’un

registre se mesure en
"bits" (16 ; 32, 64...)

C'est cette "largeur"

qui donne la taille de
travail du µprocesseur.
Un µP de 32 bits a des
registres de 32 bits de
large

Le bus interne à la
même taille que les
registres

Le bus de sortie peut être différent du bus interne ( Exemple : 32 interne/16 externe). Le nombre
d’entrées et de sorties peut être découplé.
Le « Séquenceur d’instructions », ou « Décodeur d’instructions » est un automate piloté par
une horloge (« Xtal »).

1 – 2 – Mode de fonctionnement :

Exemple : le "29000" d’AMD

Soit l’opération : a = b + c Ceci est une instruction de haut niveau, qu’il faudra traduire en
une suite d’instruction en langage machine.

8
a , b et c sont des variables dans l'espace mémoire datas

Mémoire Datas

Prendre la valeur « b » et la mettre dans le registre R1

Prendre la valeur « c » et la mettre dans le registre R2

L ‘ « ALU » additionne « b » & « c » et met le résultat dans le registre R3

Mémoriser la valeur du registre R3

dans la mémoire à l'adresse a a

Remarques importantes :
@b est l’adresse à laquelle se trouve la valeur à prendre. Le problème est que celle-ci
comporte 32 bits il n’est donc pas possible de charger, sur 32 bits, l’instruction, l’adresse et le
numéro de registre. L’opération doit s’effectuer en deux fois. Elle s'écrit donc sur 2 cases de la
mémoire :
Ld R1, Où cela va
@b L’adresse de « b » d’où cela vient

On remarque part ailleurs que certaines opérations s’effectuent sur deux cycles, alors que
d’autres n’en nécessitent qu’un, pour les raisons suivantes :

- Les opérations internes s’effectuent en un

cycle ;
- Les opérations externes
s’effectuent en Deux cycles.

Toutes les instructions qui transfert des données entre la mémoire et les registres ont en 2 cycles

En additionnant le nombre de cycles, nous voyons qu’il en faut sept, autant que de « cases »
mémoire, pour effectuer le programme, C’est aussi le nombre de mesures que doit battre le
cristal pour exécuter le programme.

Remarque :
On peut regrouper les 2 mémoires en 1 seules.
La mémoire est alors contiguës mais il faut des
emplacements séparés et délimités pour la mémoire
programme et la mémoire de données.
C'est ce shéma que l'on a sur tout les ordinateurs actuels.

9
10
1 – 3 – compilateur/évaluateur/interpréteur :
La formule a = b + c est une opération comprise par un langage de haut niveau tels que les
« basic », « C », « Java », etc.
Il faut donc adapter ce langage en une forme compréhensible par le microprocesseur. Ce travail
se nomme compiler ou évaluer/interpréteur. C'est la traduction entre un langage évolué et
l ‘assembleur.

Langage évolué assembleur

ld R1, @b
Compilateur ld R2, @c
a=b+c  
Évaluateur/Interpréteur add R1, R2, R3
st @a, R3

On utilise donc un langage évolué pour écrire un programme. Puis on traduit ce programme en
langage machine au moyen d'un compilateur ou d'un interpréteur.
Les langages compilés sont plus rapides mais plus compliqués à mettre en œuvre. Alors que les
langages évalués ou interprétés sont plus simples à écrire mais plus difficile à mettre au point et
plus lent.

2 – Processeurs RISC & CISC :

(Reduce Instruction Set Computer)
(Complexe Instruction Set Computer)

L’assembleur est un langage machine pratiquement compréhensible par le décodeur

d’instructions. Ce qui n’est pas le cas d’un langage où il faut un compilateur ou un évaluateur.
A l’origine, les programmes s’écrivaient en assembleur, ce qui donnait des instructions
complexes et le décodeur d’instructions prenait beaucoup de place, ce qui limitait d’autant la
place des registres.
Si, par exemple, pour faire l’opération suivante : a = b + c + d + e + f
Il n’y a pas la totalité des registres nécessaires, mais que deux, les opérations successives
seraient de ce genre :
b R’ ( b R’ se traduit par Ld @b, R' )
cR"
R'+R"R"
d R'
R'+R"R"
e R'
R'+R"R"
f R'
R'+R"R"
R"a
Cela n'est possible que parce que l'addition est une opération associative.

11
 Mais si on se trouve devant une formule du type : a = ((b + c) * (d – e)) / f
La procédure de résolutions se complexifie car il faut sauvegarder des résultats partiels dans la
mémoire de données, ce qui donne :
actions Opérations cycles commentaire
Ld @b, R1
On charge b et c dans les registres R1 et R2
Ld @c, R2 b + c R1 5
et on fait l'addition du 1er terme
add R1, R2, R1
Push R1 sauver R1 2 Il faut sauvegarder R1 dans la pile
Ld @d, R1
On fait le 2ieme terme de l'équation, que
Ld @e, R2 d – e  R2 5
l'on range dans R2
subb R1, R2, R2
Pop R1 Restorer R1 2 Il faut récupérer la valeur dans la pile
mul R1,R2, R1 R1*R2 R1 1 On multiplie les 2 termes de l'équation
Ld @f, R2
Op/f 3 On fait la dernière opération
div R1, R2, R1
St R1,@a R1a 2 On écrit le résultat en mémoire

On arrive à un total de 20 cycles.

Plus il y a des instructions complexes, plus le décodeur d’instructions est gros, et moins il y a
de registres.
Alors que si nous avons un micro processeur avec suffisamment de registres (par ex. 32) on a :
actions cycles commentaire
Ld @b, R1
Ld @c, R2 5*2
Ld @d, R3 = On charge toutes les variables dans les registres
Ld @e, R4 10
Ld @f, R5
add R1, R2, R1
subb R3, R4, R2
4 On fait toutes les opérations
mul R1,R2, R1
div R1, R5, R1
St R1,@a 2 On écrit le résultat en mémoire
On arrive à un total de 16 cycles.

En diminuant le nombre d’instructions et leurs complexités, la taille du D.I. fait de même

et il y a plus d’espace pour les registres.

Nota: On voit que le 2ieme l'assembleur est plus simple et plus régulier que le 1er. Il est donc plus
facile à obtenir à partir d'un compilateur. Les compilateurs travaillent mieux avec des
RISC qu'avec des CISC. Les programmes sont plus compacts et donc plus rapides.

L’architecture CISC est uniquement utilisée par le pentium, d’INTEL et l’athlon d’AMD qui
ne travaillent qu’avec deux registres.

L’architecture RISC est utilisée par le power PC qui lui possède 64 registres. Dont sont équipés
les MAC d’APPLE. Ce qui explique pourquoi un MAC est plus rapide qu’un PENTIUM à
fréquence égale, et que ce dernier est le plus mauvais des microprocesseurs sur le marché.
L’architecture RISC est utilisée par les serveurs qui sont tous sous UNIX, ce système n’est pas

12
uniformisé et les différends développeurs n’ont pas su s’accorder pour la réalisation de suites
bureautiques et autres. Brèche dans laquelle s’est engouffré INTEL & MICROSOFT en
proposant différends logiciels adéquats pour lancer le travail sur ordinateur.
Le problème de cette adéquation est que si l’un des leaders actuel de la micro-
informatique, Intel/Microsoft, fait une erreur de calcul et chute, il y entraînera automatiquement
son « complice » et tout l’édifice s’écroulera. Cette industrie est donc condamnée à plus ou
moins long terme. Pour le moment c’est la grande fuite en avant avec comme mot d’ordre
« innover ! innover ! »

UNIX se fond en un système unique et, cerise sur le gâteau, la majorité de ses logiciels
sont gratuits et disponible sur le web. Ce qui n’est pas le cas de ceux de MICROSOFT .
De plus UNIX est un système ouvert et tout le monde peut y rajouter son « grain de
sel », contrairement à WINDOWS qui est un système verrouillé.

En résumé :
UNIX  TESTEURS & CREATEURS + PROFESSIONNELS
WINDOWS  CONSOMMATEURS

Faites votre choix

3 – Processeurs actuels (2003) :

Nb. De Watts
Fabriquant Processeur Fréquence
registres dissipés
INTEL/AMD Pentium 2,7GHz 2 30
MOTOROLA/IBM/APPLE Power PC 2GHz 64 20
DEC(n’existe plus) ALPHA 2GHz 128 60
SUN Sparc 1GHz 128 20
SIL GRAPHIC Mips(128 bits) 1GHz 192 10
ACCORN Arm 500/700MHz 172 1
Légende :
CISC PC/WINDOWS
RISC STATION DE TRAVAIL
RISC CONSOMMABLES SPÉCIFIQUES (ex. téléphone portable, etc.)

Le dessin ci-contre représente l’architecture type de l’informatique, on la retrouve

systématiquement, jusque dans la
machine elle-même.

13
Exemple de programme faisant des échanges entre la mémoire et le µP

Soit à faire une fonction strlen (compter les caractères dans une chaîne) qui travaille sur une
chaîne de caractères "à la mode C".

La chaîne est un tableau de caractère située en mémoire data. C'est aussi une suite contiguë de
caractères dont la fin est marquée en C par un caractère spéciale le "/0", dont la valeur est 0.

Un tableau c'est une origine (du tableau) et une taille. On note l'origine par une variable appelée
T. Les constituants de base (cellules) de ce tableau sont des octets car les caractères tiennent sur
un octet.

On peut représenter la chaîne comme :

Le nom T est le nom du tableau qui donne le début de la chaîne.

Nota : on pouvait choisir un autre nom que T. Celui-ci n'a été pris que par fainéantise.

Algorithmique
But : Pour avoir la taille de la chaîne on doit compter les caractères en commençant au
début du tableau jusqu'à trouver le /0 terminateur.
Pré requis : Pour compter il nous faut un compteur, appelons sz (pour size).
Initialisation : Au début sz vaut 0.
boucle : tant que le caractère du tableau d'indice sz est différent du terminateur
action : on avance l'indice sz.
Fin : Quand on a atteint le caractère /0 on a dans sz la taille de la chaîne
Nota :On a pu utiliser la taille sz comme indice.

Ecriture en C

Pré requis : int sz ; on définie un entier sz.

Initialisation : sz = 0 ; on met 0 dans la variable sz
tant que le caractère du tableau T indicé
boucle : while ( T[sz] != '/0' )
par sz est différent du caractère /0
action : sz ++ ; On incrémente sz (c.a.d. sz = sz+1)

Nota: En C il n'y a rien à écrire pour la fin car on a en sortie de boucle sz qui contient la taille

14
On veut traduire ce programme C en assembleur et "voir" comment il se déroule.
Pour traduire un programme C muni d'une boucle, en assembleur, on a le schéma suivant :

Assembleur

Pour l'assembleur on a besoin de 4 registres pour stocker et indicer les variables.

On défini :
R0 sert à charger le caractère et à le tester
R1 sert à avoir l'adresse de T (le début du tableau)
R2 sert d'indice (Attention : Ce n'est pas sz qui est une variable qu'il faudra remplir)
R3 sert de constante /0 pour le test. On l'initialise et on n'y touche plus

Init :
Ld @T, R1 ; on charge l'adr du début de tableau
Xor R3,R3, R3 ; vieille astuce permettant de mettre un registre à 0 sans faire un Ld
; mais un ou exclusif. Cela se fait en 1 cycle
Mov R3, R2 ; on met /0 dans R2. (/0 vaut 0). R3 initialise aussi R2.
JMP test ; saut à l'étiquette Test (JMP = jump, c'est un saut absolu)
Corps:
Inc R2 ; incrémente R2 ( c.a.d. R2 = R2 + 1 )
Test:
Ld R1+ R2 , R0 ; charge le caractère de T et d'indice R2 dans R0
Xor R0, R3, R0 ; fait un masque entre R0 et R3, si idem alors R0 = 0
JNZ R0, Corps ; si R0 n'est pas Zéro saute à Corps (JNZ = Jump if Not Zero)
Fin:
Str R2, @sz ; on met la taille dans la variable sz en mémoire

Nota : Dans le cas du 8086 on aurait pris : R0  AX

R1  BP (base pointer)
R2  CX
R3  BX
Nota : BP est un registre de pointage en mémoire qui ne sert qu'à cela.
CX est un registre compteur qui ne sert aussi qu'à cela

15
On obtient la mémoire programme suivante :

étiquettes instructions Nbr cycles

Nbr cycles
du bloc
Init : Ld ,R1
2
@T
Xor R3,R3, R3 1
6
Mov R3, R2 1
Jmp
2
Test
Corps: Inc R2 1
Test: Ld , R0
2
R1+ R2
6
Xor R0, R3, R0 1
JNZ R0,
2
Corps
Fin: Str R2,
2 2
@sz

Si on fait un petit calcul on a :

- Le programme fait 14 cycles d'instructions (cependant cela ne signifie pas grand chose car
il y a une boucle qui s'exécute sur un certain nombre d'éléments de tableau)
- L'init fait 6 cycles ce qui est rapide
- La boucle complète avec son corps fait 6 cycles. Si on travail sur un tableau de 1000
éléments on aura 1000*6 cycles = 6000 cycles.
- La fin fait 2 cycles ce qui est négligeable.

On voit l'importance d'avoir du code bien écrit afin d'avoir des programmes les plus courts
possibles. Si on avait mal travaillé et qu'1 seule instruction d'1 cycle soit rajouté dans la boucle
et si on travail sur 1000 éléments on augmente de 1000 cycles la durée totale du programme.
C.a.d. une augmentation d'environ 1/6 ce qui représente 16% du temps, et cela pour 1 seule
instruction en plus.

On comprend mieux alors l'importance d'avoir :

1) un µprocesseur qui ait beaucoup de registres et des instructions performantes
2) un compilateur qui sache bien traduire les programmes que l'on écrit en étant le plus
efficace possible.

Nota: Ce programme est tout à fait réaliste. C'est un programme du même genre qui est utilisé
quand on demande des statistiques sous Word (Fichier , Propriétés Statistiques). Par ex.
ce document contient 12413 caractères on a donc un tableau de 12413 éléments.

16