Agata Savary , IUT de Blois, D épartement GTR, 1 e année , 200 4 -200 5

Architecture des ordinateurs

cours 3Micro-instructions et unité de contrôle, langage machine, langage d’assemblage, modes d’adressage

Agata Savary, IUT de Blois, Département GTR, 1e année, 2004-2005

A. SAVARY IUT Blois GTR1, 2004/05 2

Micro-instructionsUnité de contrôle


Dans JASPer il y a essentiellement 2 types de micro-instructions :

• Les déplacements de données, par exemple

A [MDR] signifie recopier le contenu du registre MDR dans le registre A

M[MAR] [MDR] signifie écrire le contenu du registre MDR en mémoire à l’adresse contenue dans MAR

• Les opérations de l’UAL, par exemple

ALUr ALUx + ALUy signifie additionner les contenus des registres ALUx et ALUy et placer le résultat dans le registre ALUr

ALUr ALUx >> 1 signifie décaler à droite le contenu du registre ALUx et placer le résultat dans le registre ALUr

Micro-instruction = une action élémentaire dans le chemin de données du processeur.

Attention : tous les déplacements de données ne sont pas admis (e.g. A [B] interdit ; il faut passer par un registre intermédiaire)


• L’unité de contrôle analyse le code de l’instruction machine courante (contenue dans le registre IR).

• Elle décode cette instruction, i.e. détermine quelles micro-instructions doivent être effectuées dans quel ordre pour exécuter l’instruction courante

• Elle envoie des signaux de contrôle au chemin de données pour imposer les micro-instructions nécessaire (par les lignes oranges du cours précédent: ContrôleUAL, AouB, VersAouB, EcrireAB,…)

Les micro-instructionssont provoquées par l’unité de contrôle

“La mise en oeuvre de l’unité de contrôle est la tâche la plus difficile de toute la conception matérielle”

(Patterson, Hennessy Organisation et conception des ordinateurs)

… c’est pourquoi nous n’allons pas l’examiner plus en détail pendant ce cours


Nous voulons effectuer l’action suivante :

additionner le contenu du registre A avec le contenu du registre B et placer le résultat dans A.

Pour ceci il faut exécuter les micro-instructions suivantes :

• copier le contenu de A dans ALUx

• copier le contenu de B dans ALUy

• additionner ALUx et ALUy et placer le résultat dans ALUr

• copier le contenu de ALUr dans A

Cela donne le microprogrammme suivant :

ALUx [A]

ALUy [B]

ALUr [ALUx] + [ALUy]

A [ALUr]

Microprogramme = un enchaînement de micro-instructions


Langage machine et

langage d’assemblage

machine language

assembly language


Dans un processeur microprogrammé (comme JASPer) chaque instruction de langage machine est réalisée par un microprogramme. Exemples :

Langage machine = langage compréhensible (exécutable) par le processeur.

Micro-programme Instruction (binaire) du langage machine Description

ALUx [A]ALUy [B]ALUr [ALUx] + [ALUy]A [ALUr]

0000 0110 0000 0000Additionner le contenu du registre A avec le contenu du registre B et placer le résultat dans A

MDR<-[A]

B<-[MDR]1001 0111 0000 0000

Copier le contenu du registre A dans le registre B

Les microprogrammes de toutes les instructions machine sont rangés dans l’unité de contrôle (sous forme d’une mémoire ROM ou bien d’un circuit combinatoire). Lorsque l’instruction courante et chargée dans le registre IR, l’unité de contrôle provoque l’exécution du microprogramme correspondant.


Format d’une instruction du langage machine JASPer

Op-code 2e opérande

8 bits 8 bits

Chaque instruction de JASPer a 2 octets :

Presque chaque instruction fait intervenir un (ou deux) registre(s), et éventuellement un deuxième opérande (s’il est inexistant le 2e champs est mis à 0).

Le “op-code” contient les informations sur :• L’opération à effectuer• Le mode d’adressage du deuxième opérande (facultatif)• Le choix du registre (A ou B)


Exemples d’instructions du langage machine JASPer

Micro-programme

Instruction (binaire) du langage machine

Hexa Commentaireop-code 2e opérande


0000 0110 0000 0000 06 00

Additionner le contenu du registre A avec le contenu du registre B et placer le résultat dans A

MDR<-[A]B<-[MDR] 1001 0111 0000 0000 97 00

Copier le contenu du registre A dans le registre B

ALUx [B]ALUy [IR(operand)]ALUr [ALUx]+[ALUy]B [ALUr]

0000 0001 0011 1110 01 5EAdditionner la valeur (5E)16 au contenu du registre B

MAR [IR(operand)]MDR [M[MAR]]A [MDR]

1001 0010 0100 0010 92 42Copier dans le registre A le contenu de la case mémoire à l’adresse (42)16


Langage d’assemblage = langage de mnémoniques pour les instructions du langage machine

Micro-programme

Instruction (hexa) du langage machine Instruction du

langage d’assemblage

Commentaireop-code 2e opérande


06 00 ADD B,AAdditionner le contenu du registre A avec le contenu du registre B et placer le résultat dans A

MDR<-[A]B<-[MDR] 97 00 MOVE A,B Copier le contenu du registre

A dans le registre B

ALUx [B]ALUy [IR(operand)]ALUr [ALUx]+[ALUy]B [ALUr]

01 5E ADD #5E, BAdditionner la valeur (5E)16 au contenu du registre B

MAR [IR(operand)]MDR [M[MAR]]A [MDR]

92 42 MOVE 42,ACopier dans le registre A le contenu de la case mémoire à l’adresse (42)16


Langage d’assemblage et langage machine

Langage d’assemblage (appellé souvent assembleur) = représentation symbolique du langage machine :

• Les mnémoniques (e.g. ADD, MOVE, SHR) remplacent les codes numériques des opérations

• Les adresses symboliques (e.g. K dw 3) remplacent les adresses numériques des emplacements mémoire.

Un assembleur = compilateur qui traduit le langage assembleur en langage machine.

L’assemblage = processus de traduction (compilation) du langage assembleur en langage machine.

Pentium : resérver un double mot,le nommer ‘K’ et l’initialiser à 3


Format d’instructionsdu langage d’assemblage

Etiquette(facultative

)

Mnémonique de l’opération

à exécuter

1 ou 2 arguments

Commentaire(facultatif)

Fin HALT #Arrêter le programme

SHR (A) #Décaler le diviseur

Loop ADD #10, B #Augmenter le compteur


Langage de haut niveau vs. langage d’assemblage.


Emploi des branchements - choix

si (A = B) alors

<bloc_si>

sinon

<bloc_sinon>

finsi

<bloc_suivant>

8700 CMP A,BC2.. BNE diff

. <bloc_si>

. (en assembleur)

E0.. JMP suite

. diff <bloc_sinon>

. (en assembleur)

. suite <bloc_suivant>

. (en assembleur)

Algorithme Langage d’assemblageLangagemachine


Emploi des branchements - boucles

tant que (A>=0)

<bloc_tantque>

fin_tantque

<bloc_suivant>

8000 boucle CMP #0,Abb.. BMI suite. <bloc_tantque>. (en assembleur)

E0.. JMP boucle


. (en assembleur)

Algorithme Langage d’assemblage

répéter

<bloc_répéter>

tant que (A>=0)

<bloc_suivant>

. boucle <bloc_répéter>

. (en assembleur)

8000 CMP #0,Abb.. BMI suiteE0.. JMP boucle


. (en assembleur)

Langagemachine


Emploi des branchements - boucles

pour (i0) jusqu’à 10par pas de 2

<bloc_pour>

fin_pour

<bloc_suivant>

9100 MOVE #0,B8000 boucle CMP #0A,Bbb03 BMI corpsc302 BEQ corpse0.. JMP suite. corps <bloc_pour>. (en assembleur)0102 ADD #02,Be0.. JMP boucle. suite <bloc_suivant>. (en assembleur)

Algorithme Langage d’assemblageLangagemachine


Compilation et compatibilité


Le langage machine = l’interface entre le logiciel et le matérielChaque ordinateur a son langage machine réalisé :• soit directement par le matériel (e.g. architecure RISC)• soit par un microprogramme (e.g. JASPer)La compilation est une traduction du code source (en langage de

haut niveau) par un programme appelé compilateur en un programme exécutable (en langage machine), en passant éventuellement par le langage d’assemblage.

Pour compiler il faut :• Vérifier la syntaxe du code source• Remplacer chaque instruction du code source par une

séquence équivalente d’instructions en langage machine.• Eventuellement optimiser le code obtenu

Langage machine et compilation


Compilateur C

Assembleur

change(int v [], int k) {

int tmp;

tmp = v[k];

v[k] = v[k+1];

v[k+1] = tmp; }

Programme en langagede haut niveau, ici C

(le “code source”)

change : MOVE adr_v,A

ADD addr_k,A

MOVE (A),B

ADD #1,A

MOVE B,(A)

…

Programme enlangage assembleur

0100011011010101

0010011110101101

1101010101010010

1101010100101010

0101010010111101

1111010000100110

….

Programme en langage machine(l’“exécutable”)

Compilation en couches

Compilateur C


Compilation, assemblage et édition de liensCode source du module Ben langage d’assemblage

(e.g. B.asm)

Code source du module Aen langage de haut niveau

(e.g. A.c)

Module A compilé(e.g. A.obj)

Module B compilé(e.g. B.obj)

Module C compilé(e.g. C.obj)

Editeur de liens Programme en langage machine(l’exécutable, e.g. prog.exe):

10: module A 50: module B a0: module C

Compilateur Assembleur


• Le langage machine constitue l’interface entre le logiciel et le matériel

• Chaque processeur a son propre langage machine (et son langage d’assemblage associé) réalisé :

– soit directement par le matériel (e.g. architecure RISC)– soit par un microprogramme (e.g. JASPer), qui lui-même est réalisé par le

matériel• Chaque processeur ne peut exécuter (comprendre) que les

programmes (exécutables) écrits en son langage machine.• Conclusion : Un programme exécutable sur l’ordinateur A n’est

pas exécutable sur un autre ordinateur B sauf si les langages machine des deux ordinateurs sont compatibles.

Langage machine et la compatibilité


Compatibilité ascendante des processeurs• Un nouveau processeur (machine) respecte la comptabilité

ascendante si les applications qui tournaient sur l’ancienne machine peuvent tourner sur la nouvelle machine sans modification

• Pour qu’il y ait comptabilité ascendante le langage machine du nouveau processeur doit au moins contenir toutes les instructions de l’ancien processeur. Elles peuvent être réalisées différemment mais doivent donner les mêmes résultats (i.e. doivent avoir la même interface).

• Si manque de comptabilité ascendante, les anciens programmes doivent être soit recompilés (les codes sources doivent être disponibles), soit réécrits (e.g. s’ils ont été écrits en assembleur)

Exemple : les processeurs Intel sont compatibles en amont depuis le modèle 8086 (sorti en 1978).


Compatibilité ascendante des processeursLa compatibilité ascendante est un poids lourd pour les concepteurs

de nouveaux modèles de processeurs :• Il faut tenir compte de tous les choix faits pour la conception des

langages machines tout au long de l’histoire de la gamme de machines en question. Ces choix, souvent, ne sont pas cohérents avec les besoins et les possibilités actuelles.

• Du coup l’architecture est moins élégante et moins compacte (donc aussi moins performante) que si elle ne tenait compte que du langage machine le plus recent.

• C’est pourquoi l’introduction d’une machine totalement nouvelle (malgré son manque de compatibilité ascendante) peut s’avérer très intéressante. Ceci a été le cas de l’architecture RISC qui a proposé un jeu d’instructions très simples, peu nombreuses et exécutables très rapidement, ce qui a provoqué un gain très important de performances.


Modes d’adressage


Les valeurs auxquelles s’appliquent les opérations peuvent provenir :

– directement de l’instruction (adressage immédiat) : 0010 ADD #10, B #Augmenter le contenu du registre B de

10

– des registres, (adressage par registre)

0700 ADD A, B #Additionner les contenus des registres A# et B ; placer le résultat dans le registre

B

– de la mémoire (adressage direct, indirect ou indexé) 3800 SHL (A) #Décaler à gauche un argument

#dont l’adresse est dans le registre A

Modes d’adressage


Adressage immédiat

La valeur de l’argument est une constante provenant directement de l’instruction, elle est précédée d’un “#”.

Exemples :

0110 ADD #10, B #Additionner le contenu du registre B#avec la constante 10; placer le résultat#dans le registre B

9110 MOVE #10, B #Placer la constante 10 dans le registre B

e810 JMP #10 #Aller à la 9e instruction en comptant #à partir de l’instruction courante


Adressage par registre

Dès le début de l’instruction la valeur de l’argument se trouve dans un registre.

Exemples :

0700 ADD A, B #Additionner le contenu du registre B#avec le contenu du registre B; placer le#résultat dans le registre B

3700 SHL B #Décaler le contenu du registre B à gauche

e200 JMP A #Aller à l’instruction dont l’adresse#est contenue dans le registre A


Adressage immédiat et par registre - microcode

Exemple :

Opcode e8

Mnemonic "JMP #dis"

Description "Jump to a PC relative address"

ALUx[PC]

ALUy[IR(operand)]

ALUr[ALUx]+[ALUy]

PC[ALUr]

Saut à une adresserelative au PC courant

Premier argument provient duregistre PC : adressage par registre

Deuxième argument provient del’instruction : adressage immédiat

Code d’opération(en hexa)


Adressage directLa valeur de l’argument se trouve dans la mémoire à l’adresse indiquée directement dans l’instruction.

Exemples :

9210 MOVE 10,A #Placer dans le registre A le contenu #de la case mémoire à l’adresse 10

4210 SHR 10 #Décaler à droite le contenu de la case#mémoire à l’adresse 10

10 4Mémoire avantl’instruction SHR 10:

Mémoire aprèsl’instruction :

10 2


Adressage direct - microcode

Exemple :

Opcode 92

* addr 00 to FF

Mnemonic "MOVE addr,A"

Description "Load reg. A from a direct addr."

MAR[IR(operand)]

MDR[M([MAR])]

A[MDR]

Chargement d’un argumentdirect dans A

L’adresse de l’argumentprovient de l’instruction

L’argument provient de l’adresse mémoire trouvée dans l’instruction


Adressage indirect

10 14

14 4

Mémoire avantl’instruction SHR (10):

10 14

14 2

Mémoire aprèsl’instruction

La valeur de l’argument se trouve dans la mémoire à l’adresse indiquée par un registre ou par une autre case mémoire dont l’adresse se trouve dans l’instruction. Ce registre ou cette dernière adresse apparaît entre parenthèses.

Exemples :

4800 SHR (A) #Décaler à droite le contenu de la case mémoire # dont l’adresse se trouve dans le registre A

4410 SHR (10) #Décaler à droite le contenu de la case mémoire #dont l’adresse se trouve dans la case mémoire 10


Adressage indirect - microcode

Exemple :Opcode 44* addr and (addr) 00 to FFMnemonic "SHR (addr)"Description "Shift right a memory indirect oper."MAR[IR(operand)] MDR[M([MAR])] IR[MDR] MAR[IR(operand)] MDR[M([MAR])] ALUx[MDR] ALUr[ALUx]>>1 MDR[ALUr] M([MAR])[MDR]

Décalage à droite d’un argument indirect

L’instruction contient un pointeurvers une case mémoire…

…où se trouve l’adressed’une autre case mémoire…

…où se trouve l’argument


Adressage indexé

Mémoire avantl’instruction SHR B+10:

Mémoire aprèsl’instruction :Registre B:

6

16 4 16 2

La valeur de l’argument se trouve dans la mémoire à l’adresse qui est la somme du contenu d’un registre avec la valeur qui se trouve dans l’instruction.

Exemple : 4b10 SHR B+10 #Décaler à droite le contenu de la #case mémoire dont l’adresse est #la somme du registre B et 10


Adressage indexé - microcode

Exemple :Opcode 4b* addr 00 to FFMnemonic "SHR B+addr"Description "Shift right a memory indexed oper. (Index in B)"ALUy[IR(operand)] ALUx[B] ALUr[ALUx]+[ALUy] MAR[ALUr] MDR[M([MAR])} ALUx[MDR] ALUr[ALUx]>>1 MDR[ALUr] M([MAR])<-[MDR]

Décalage à droite d’un argument indexé

L’instruction contient la valeurqu’il faut additionner avec B…

…pour obtenir l’adresse effective de l’argument


Résumé - architecture en couches


• Les instructions du langage d’assemblage sont mises en oeuvre par des fonctionnalité du système d’exploitation (appels système) et par des instructions du langage machine.

• Les instructions du langage machine peuvent être mises en oeuvre soit par des séquences de microinstructions, soit directement par le matériel.

• Les microinstructions sont des instructions qui provoquent des signaux matériels de base donnés par l’unité de contrôle au chemin de données.

Architecture en couches (rappel)

• Les instructions du langage de haut niveau sont mises en oeuvre soit par des instructions du langage d’assemblage, soit directement par des appels système et celles du langage machine .

Matériel

Documents

Agata Savary , IUT de Blois, D épartement GTR, 1 e année , 200 4 -200 5