ppt, 199KB

Instructions



Types d’instructions
Séquencement
Contrôle
MÉMOIRE
PRINCIPALE
IO
IO
IO
BUS SYSTÈME
Cache
Instructions
Unité de
Contrôle
CPU
Décodeur
Unité de
Traitement
ALU
Unité
Flottante
PC
Registres
Cache
Données
Contrôle de l’unité de traitement
OUTPORT
UNITÉ
DE
CONTRÔLE
3
3
3
3
3
OEN
SEL
AL[2:0]
SH[2:0]
RA[2:0]
RB[2:0]
WEN
WA[2:0]
OEN SEL AL[2:0]
OEN
Z≠0
RA 3
RB 3
WEN
WA 3
Z≠0
SH[2:0]
OPÉRATION
INPORT
WEN
SEL
1 0
AL2
AL1
AL0
I0
I1
Z
SH2
SH1
SH0
SHIFTER
R0 R1 R2 R3 R4 R5 R6 R7
RA[2:0]
RB[2:0]
OPÉRANDES
WA[2:0]
Contrôle par instructions - Décodage
Adresse
0:0|1
1:2
2:3
3:4
4:5
5:6
6:7|4
7:0
Opérandes
0:R1
1:R0,R2
2:R0,R3
3:
4:R1,R3,R4
5:R2,R4,R2
6:R1,R1
7:R2
Contrôle
0:AIN
1:BA
2:BA+1
3:NOP
4:
5:
6:
7:
Instruction
n BASCULES
Opcode Opérandes
0:data  inport
1:ocount  0
2:mask  1
3:while data ≠ 0
4:tempdata AND mask
5:ocountocount+temp
6:data  data >> 1
end while
7:outport  ocount
CK
Fanions
SLC
SLC
RAM
CA&B
CA+B
BA>>1
OUTA
Chaque instruction doit permettre de générer les bits de contrôle pour
l’unité de traitement ainsi que l’adresse de l’instruction suivante.
Format des instructions: exemple
Le codage des instructions est, en général, arbitraire:
LOAD
MOVE
INC
BRA
AND
ADD
SHR
BRA
STORE
ADR, R1
R0, R2
R0, R3
ADR, COND
R1, R3, R4
R2, R4, R2
R1, R1
ADR, COND
ADR, R2
OPCODE
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
0 1 1
1 1 1
OPER1 OPER2
Adresse[5:0]
0 0 0 0 1 0
0 0 0 0 1 1
Adresse[5:0]
0 0 1 0 1 1
0 1 0 1 0 0
0 0 1 0 0 1
Adresse[5:0]
Adresse[5:0]
OPER3
0 0 1
ø ø ø
ø ø ø
data=0
1 0 0
0 1 0
ø ø ø
vrai
0 1 0
Compilation
program toto;
var
A, B, C : array [1...1000] of integer;
i : integer
begin
...
for i:=1 to 1000 do
C[i] := A[i] + B[i];
...
end
COMPILATEUR
Algorithme

Langage de haut-niveau

Langage machine
= jeu d’instructions
...
MOVE.L
MOVE.L
MOVE.L
START: ABCD
MOVE.B
TEST: CMPA
BNE
...
#2001,A0
#3001,A1
#4001,A2
-(A0),-(A1)
(A1),(A2)
#1001, A0
START
Opération du processeur - Opcodes
Un processeur non-spécialisé (general-purpose) doit avoir un
jeu d’instructions qui soit:
 Complet:
il doit pouvoir exécuter toute fonction calculable;
 Efficace: il doit exécuter rapidement les fonctions les plus utilisées;
 Régulier: il doit contenir les fonctions attendues (p.ex., s’il y a un
décalage à gauche, il doit y avoir un décalage à droite);
 Compatible?: si nécessaire, il doit être compatible avec le jeu d’une
machine existante.
Tout algorithme est réalisé par une séquence (série)
d’instructions.
Boucle de traitement
Début
Instructions
en attente?
NON
OUI
Chargement
Décodage
Interruptions
en attente?
OUI
Traitement
NON
Les instructions sont stockées en mémoire,
comme n’importe quelle donnée. À chaque
instruction correspond donc un adresse.
Chaque instruction est chargée dans le
processeur, décodée pour déterminer sa
fonction et les bits de contrôle pour l’unité de
traitement sont générés en conséquence.
L’unité de traitement effectue l’opération
désirée sur les données.
Si une interruption est en attente, elle a
normalement précédence sur les instructions,
et elle est donc traitée immédiatement.
Types d’instructions - Opcode
 Transfert

de données
Transferts d’informations entre positions mémoire (interne ou
externe au processeur)
 Arithmétique

Opérations sur données numériques
 Logique

Opérations booléennes et autres
 Entrées/sorties

(I/O)
Transferts d’informations entre le processeur ou la RAM et les
unités externes
 Contrôle

Instructions qui modifient le flot d’instructions
Format des instructions: exemple
data  inport
ocount  0
mask  1
while data ≠ 0
temp  data AND mask
ocount  ocount + temp
data  data >> 1
end while
outport  ocount
=
=
=
=
=
=
=
=
=
LOAD
MOVE
INC
BRA
AND
ADD
SHR
BRA
STORE
ADR, R1
R0, R2
R0, R3
COND, ADR
R1, R3, R4
R2, R4, R2
R1, R1
1, ADR
ADR, R2
[T]
[T]
[A]
[C]
[L]
[A]
[L]
[C]
[T]
Format des instructions
Opcode Conditions
Opérandes (3)
Prochaine(s) instruction(s)
Beaucoup d’information! P.ex., une architecture avec 256 instructions,
16 fanions, 64 registres et un bus (adresse) de 32 bits aurait besoin,
même si tous les opérandes sont des registres (ce qui n’est pas le cas),
de
8 + 4 + 6x3 + 32x2 = 94 bits!
Une solution est de coder les instructions sur plusieurs mots mémoire.
Ce fut une technique très utilisée dans le passé (processeurs 8 et 16
bits) et le reste aujourd’hui pour certains types d’instructions. Elle
introduit cependant beaucoup de délai (plusieurs coups d’horloge par
instruction, décodage complexe).
Des simplifications sont nécessaires!
Format des instructions - Simplifications
Première simplification: chaque type d’instruction nécessite des
informations différentes.
Transferts de données: 78 bits (un opérande peut être une adresse)
Opcode
Opérandes (2)
Prochaine instruction
Opérations arithmétiques et logiques: 58 bits (que des registres)
Opcode
Opérandes (3)
Prochaine instruction
Opérations d’entrée/sortie: 78 bits (un opérande peut être une adresse)
Opcode
Opérandes (2)
Prochaine instruction
Instructions de contrôle: 76 bits
Opcode Conditions Prochaine(s) instruction(s)
Format des instructions - Simplifications
Deuxième simplification: par défaut, on peut définir la prochaine
instruction comme étant l’instruction suivante en mémoire.
Adresse
0:+1|0
1:+1
2:+1
3:+1
Instruction
n BASCULES
Opcode Opérandes
Fanions
SLC
RAM
Contrôle
CK
SL
Opérandes
0:data  inport
1:ocount  0
2:mask  1
3:while data ≠ 0
4:tempdata AND mask
5:ocountocount+temp
6:data  data >> 1
end while
7:outport  ocount
4:+1
5:+1
6:+1|4
7:0
Séquenceur
Fanions
RAM
PC
Opérande
Contrôle
CK
SLC
Opérandes
n BASCULES
Opcode Opérandes
Instruction
Adresse
Séquenceur
CK
Adresse
Opcode
Condition
Fanions
+1
CK
SLC
Format des instructions - Simplifications
Transferts de données: 46 bits (un opérande peut être une adresse)
Opcode
Opérandes (2)
Opérations arithmétiques et logiques: 26 bits (que des registres)
Opcode
Opérandes (3)
Opérations d’entrée/sortie: 46 bits (un opérande peut être une adresse)
Opcode
Opérandes (2)
Instructions de contrôle: 44 bits
Opcode Condition Prochaine instruction
Toujours trop grandes! Il faut trouver d’autres simplifications.
Opérations arithmétiques et logiques
Les opérations arithmétiques et logiques peuvent, en théorie, être
effectuées directement sur des données en mémoire (CISC):
add adr1,adr2,adr3
(8+32x3=104 bits!)
En pratique, pour simplifier le contrôle du processeur, ce type
d’opérations est toujours fait avec des données préalablement placées
dans les registres du processeur (RISC):
add rx,ry,rz
(8+6x3=26 bits)
Grâce à cette approche, 32 bits sont normalement suffisants pour
stocker une instruction complète. Pour des processeurs plus petits
(16 bits), on peut toujours réduire le nombre d’opérandes à deux:
move rx,rz
add ry,rz
Transferts de données et I/O
Pour les transferts de données et pour le traitement des entrées/sorties,
on ne peut pas se passer de références à la mémoire principale.
L’instruction doit coder soit les données elles-mêmes, soit des
indications sur comment l’unité de traitement peux les retrouver.
Encore une fois, les transferts de données peuvent, en théorie, être
effectués directement sur des adresses mémoire:
move adr1,adr2
(8+32x2=72 bits)
En pratique, pour simplifier le contrôle du processeur, un des
opérandes (la source ou la destination, indifféremment) dans ce type
d’opérations est toujours un des registres du processeur:
move adr,rx
(8+ 32+6=46 bits)
Cette approche réduit le nombre de bits nécessaires pour codes ces
instructions, mais pas suffisamment. Le problème est résolu (plus ou
moins) par l’utilisations de modes d’adressage.
Modes d'adressage
Pour les transferts de données et pour le traitement des entrées/sorties,
on suppose donc que l’un des opérandes est un registre. L’autre
opérande doit coder soit les données elles-mêmes, soit leur
emplacement dans la mémoire principale (adresse).
Petit exemple:
MAX = 100;
CNTR = MAX/2;
ARR = MALLOC(MAX*sizeof(INT));
START_VAL = *(ARR);
END_VAL = *(ARR + 100);
CNTR_VAL = *(ARR + CNTR);
START = ARR;
END = ARR + MAX;
FOR (I=0; I<CNTR; I++) {
BOTTOM_HALF += *(START);
START += sizeof(INT);
TOP_HALF += *(END-sizeof(INT));
...
}
Adressage immédiat
Si les données sont stockées directement dans l'instruction elle-même,
on parle d’adressage immédiat ou littéral:
move data,rx
Opcode
Data
Destination (Rx)
Il faut remarquer que les données de ce type d’instruction ont
forcément une taille limitée par largeur de l’instruction (dans notre
exemple, 32 - 8 - 6 = 18 bits).
Dans notre exemple:
MAX = 100;
Adressage par registre
Les données peuvent être préalablement stockées dans un des
registres du processeur. On parle dans ce cas d’adressage par registre:
move ry,rx
Opcode
Source (Ry)
Destination (Rx)
Banc des
registres
Opérande
Les données dans ce type d’instructions ont une taille égale à la
largeur des registres.
Dans notre exemple:
CNTR = MAX/2;
Adressage direct
Si le deuxième opérande doit indiquer l’emplacement des données en
mémoire principale, on peut coder directement l’adresse dans
l’instruction. On parle dans ce cas d’adressage direct ou absolu:
move adr,rx
Opcode
Source (adresse)
Destination (Rx)
Mémoire
MMU
Opérande
La taille des adresses est ici limitée par la largeur de l’instruction.
Les bits restants sont implicites (ajoutés par la MMU).
Ce mode d'adressage est très rarement utilisé dans les programmes
écrits par l'utilisateur. Par contre, il est très commun dans les OS:
ARR = MALLOC(MAX*sizeof(INT));
Adressage indirect par registre
L’emplacement (adresse) des données en mémoire principale peut
aussi être préalablement stocké dans un des registres du processeur.
On parle dans ce cas d’adressage indirect par registre:
move (ry),rx
Opcode
Source (Ry)
Destination (Rx)
Banc des
registres
Mémoire
Adresse
Opérande
Les adresses dans ce type d’instructions ont une taille égale à la
largeur des registres.
Dans notre exemple:
START_VAL = *(ARR);
Adressage indirect via mémoire
L’emplacement (adresse) des données en mémoire principale peut
être lui-même stocké en mémoire principale. On parle dans ce cas
d’adressage indirect via mémoire:
move (adr),rx
Opcode
Source (adresse)
Destination (Rx)
Mémoire
Opérande
MMU
Adresse
La taille des adresses est ici limitée par la largeur de l’instruction. Les
bits restants sont implicites (ajoutés par la MMU).
Comme l'adressage direct, ce mode d'adressage est très rarement
utilisé dans les programmes écrits par l'utilisateur mais il est très
commun dans les OS.
Adressage avec déplacement
L’emplacement (adresse) des données en mémoire principale peut
être défini comme un déplacement (offset) par rapport à une adresse
de base stockée dans un des registres. Si le déplacement est stocké
dans l'instruction, on parle d’adressage avec déplacement ou basé:
move dpl(ry),rx
Opcode
Offset
Base (Ry)
Destination (Rx)
Banc des
registres
Adresse
Mémoire
+
Opérande
La taille des adresses est égale à la largeur des registres. Par contre, la
taille du déplacement est limitée par la taille de l'instruction.
Dans notre exemple:
END_VAL = *(ARR + 100);
Adressage indexé
L’emplacement (adresse) des données en mémoire principale peut
être défini par la somme d’une adresse de base stockée dans un
registre et d’un déplacement (index) stocké dans un autre registre.
On parle dans ce cas d’adressage indexé:
move (ry+rz),rx
Opcode
Base (Ry)
Index (Rz)
Destination (Rx)
Mémoire
Banc des
registres
Offset
+
Opérande
Adresse
Les adresses et le déplacements dans ce type d’instructions ont une
taille égale à la largeur des registres.
Dans notre exemple:
CNTR_VAL = *(ARR + CNTR);
Adressage auto-incrémenté
Pour parcourir une série de positions mémoire successives (p.ex. lors
de l’accès à une table), il est utile d’incrémenter une adresse avant ou
après chaque accès. Il s'agit de l’adressage auto-incrémenté.
Post-incrément:
Opcode
move (ry)+,rx
Source (Ry)
Destination (Rx)
Banc des
registres
Mémoire
Adresse
Opérande
+
Les adresses dans ce type d’instructions ont une taille égale à la
largeur des registres.
Taille de la donnée
Dans notre exemple:
BOTTOM_HALF += *(START); START += sizeof(INT);
Adressage auto-décrémenté
Pour parcourir une série de positions mémoire successives à partir
de la fin, il est utile de décrémenter une adresse avant ou après
chaque accès. On parle dans ce cas d’adressage auto-décrémenté.
Pre-décrément:
move -(ry),rx
Opcode
Source (Ry)
Destination (Rx)
Taille de la donnée
Banc des
registres
Adresse
Mémoire
-
Opérande
Les adresses dans ce type d’instructions ont une taille égale à la
largeur des registres.
Dans notre exemple:
TOP_HALF += *(END-sizeof(INT));
Petit exemple bien compliqué
program toto;
var
A, B, C : array [1...1000] of integer;
i : integer
begin
for i:=1 to 1000 do
C[i] := A[i] + B[i];
end
...
MOVE.L #2001,A0
Charger l’adresse 2001 dans le registre A0
(pointeur sur le vecteur A)
MOVE.L #3001,A1
Charger l’adresse 2001 dans le registre A1
(pointeur sur le vecteur B)
MOVE.L #4001,A2
Charger l’adresse 2001 dans le registre A2
(pointeur sur le vecteur C)
START: ABCD
-(A0),-(A1)
Décrémenter le contenu de A0 et A1 (adresses),
puis additionner les données (1 byte BCD)
MOVE.B (A1),-(A2)
Décrémenter A2 et stocker le résultat (1 octet)
dans le vecteur C
TEST: CMPA
#1001, A0
Comparer le contenu de A0 (adresse) avec 1001;
Z=1 si les deux valeurs sont égales, Z=0 sinon
BNE
START
Sauter à START si Z n’est pas égal à 1
...
Instructions de contrôle
Les instructions de contrôle (essentiellement des branchements)
doivent nécessairement indiquer une adresse (la cible du
branchement):
if (cond) then [continue] else [branche]
Opcode Condition
Adresse cible
En théorie, cette cible pourrait être n’importe quelle position mémoire.
En pratique, dans la grande majorité des cas, il s’agit d’un saut à une
instruction dont la position mémoire est relativement proche de
l’instruction qui est en train de s’exécuter.
Par conséquent, le mode d’adressage couramment utilisé pour les
instructions de contrôle est l’adressage par déplacement, où la base est
définie implicitement comme étant le PC.
Opcode Condition
Offset
Branchement par déplacement
Instruction
n BASCULES
Opcode Opérandes
Fanions
SLC
RAM
Contrôle
CK
0:+1|+0
1:+1
2:+1
3:+1
Opérandes
0:data  inport
1:ocount  0
2:mask  1
3:while data ≠ 0
4:tempdata AND mask
5:ocountocount+temp
6:data  data >> 1
end while
7:outport  ocount
Séquenceur
CK
Adresse
4:+1
5:+1
6:+1|-2
7:-7
Séquenceur
Fanions
RAM
Contrôle
CK
PC
+1
CK
Offset
Opcode
Condition
Fanions
+
SLC
Opérandes
n BASCULES
Opcode Opérandes
Instruction
Adresse
Séquenceur
CK
Adresse
SLC