Post on 15-Mar-2016
description
Séqu
enceur
CK
n BASC
ULES
Opcode Opérandes
Fanions
RAM
Contrôle
SLC
Opérandes
Instruction
AdresseCK
Résumé
CK
Offset
SLCOpcode
ConditionFanions
+1
Adresse
+
PC
Résumé
Mémoire
Séqu
enceur
CK
IROpcode Opérandes
Fanions
RAM
Contrôle
SLC
Opéran
des
MDR MARCK
PC
PC+PC+offset
PC+ adresse initiale
MAR PC+
MDR M[MAR]IR+ MDR
décodification de IR
PC+PC+1
saut?
contrôle?
adresse?
exécution
chargement
OUI
NONOUI
NONOUI NON
CK
Procédures Lors de l'appel à une procédure, l'unité de
contrôle doit effectuer les opérations suivantes: Placer les paramètres là où la procédure peut les
récupérer Transférer le contrôle à la procédure Réserver l'espace mémoire demandé par la procédure
(sauvegarder les valeurs des registres) Exécuter la procédure Placer le résultat là où le caller (le programme qui a
appelé la procédure) peut le récupérer Transférer le contrôle au caller
Appel de procédureUne procédure est appelée par une seule et unique instruction (p.ex. jal Adresse dans MIPS).
Les registres sont l'endroit le plus efficace pour stocker les paramètres et les résultats d'une procédure. Certaines architectures (p.ex. MIPS) réservent des registres pour cela (p.ex. l'architecture MIPS réserve $a0-$a3 pour les paramètres et $v0-$v1 pour les résultats).
Lors de l'appel d'une procédure, le caller doit stocker les paramètres dans les registres appropriés, où la procédure pourra les récupérer. De la même façon, la procédure doit stocker les résultats dans les registres dédiés avant de terminer et transférer le contrôle au caller.
Appel de procédureLe retour d'une procédure est également effectué par une seule et unique instruction (p.ex. jr $ra dans MIPS). Lors de l'appel d'une procédure, le caller doit lui fournir un adresse de retour (correspondant à l'adresse de l'instruction à exécuter une fois la procédure terminée).
Lors d'un appel de procédure, il est donc nécessaire de stocker aussi cette adresse de retour. Cette adresse peut également être stockée dans un registre (p.ex. MIPS stocke cette adresse dans un registre dédié, $ra). Cette adresse est normalement l'adresse de l'instruction suivante l'appel de procédure.
Appel de procédure - Exemple ISupposons qu'un programme appelle la procédure suivante:
int P1 (int g, int h) {int f;f = g + h;return f;
}
Et qu'il a stocké g dans $a0 et h dans $a1. Si $ra contient l'adresse de retour, le code compilé pour cette procédure est (ou plutôt, pourrait être):
P1: add $a0,$a1,$v0 {$v0 résultat}jr $ra {retour}
Appel de procédure - Exemple IILors d'un retour de procédure, les registres doivent contenir les mêmes valeurs qu'ils avaient avant l'appel de la procédure. Cette obligation peut causer des problèmes quand la procédure doit stocker des valeurs intermédiaires (et a donc besoin des registres). Par exemple:
int P2 (int g, int h, int i, int j) {int f;
f = (g + h) - (i + j);return f;
}
Appel de procédure - Le stackIl est donc nécessaire de sauvegarder l'état de ces registres lors d'un appel à une procédure. Cette opération est effectuée à l'aide d'une pile ou stack.
Une portion de la mémoire principale est réservée pour stocker toute information nécessaire aux appels de procédure. Chaque processeur contient un registre (le stack pointer ou SP) qui stocke l'adresse du dernier mot de cette pile.
Lors de l'appel d'une procédure, le contenu des registres qui vont être "écrasés" par la procédure est sauvegardé dans le stack.
Appel de procédure - Exemple IIint P2 (int g, int h, int i, int j) {
int f;
f = (g + h) - (i + j);return f;
}Pour cet exemple, on suppose que $a0 contient g, $a1 contient h, $a2 contient i et $a3 contient j. P2:push $r0,+($sp) {sauvegarde du contenu de r0
push $r1,+($sp) { et r1; sp pré-incrémenté}add $a0,$a1,$r0add $a2,$a3,$r1sub $r0,$r1,$v0 {$v0 résultat}pop ($sp)-,$r1 {restauration de r0 et r1;pop ($sp)-,$r0 { sp post-décrémenté}jr $ra {retour}
Appel de procédure - Le stack
$SP
$R1$SP
$SP$R0
Avant Pendant Après
Le stack Le stack peut aussi être utilisé pour stocker des paramètres (dans le cas du MIPS, s'il y a plus que 4 paramètres). Ces paramètres peuvent être stockés soit directement (valeur) soit indirectement (adresse).
$SP
Sauvegarde$SP
$SPParamètres
Avant Pendant Après
Procédures imbriquées et récursivesLors d'un appel de procédure imbriqué (ou lors d'une procédure récursive), il faut aussi sauvegarder:• l'adresse de retour de la première procédure;• les paramètres passés à la première
procédure, s'ils sont passés en utilisant des registres (p.ex. a0-a3 dans le MIPS).
Par exemple:int P3 (int n) {
if (n<1)return (1);
elsereturn (n * P3(n-1));
}
Sauvegarde
$SP
Paramètres
Adressede retour
Sauvegarde
Paramètres
Adressede retour
Appel de procédure - Exemple IIIPour cet exemple, on suppose que $a0 contient n.
P3: push $ra,+($sp) {sauvegarde de l'adresse depush $a0,+($sp) { retour et du paramètre}bgt $a0,#1,L1 {saut sur L1 si n>1}move #1,$v0 {$v0 résultat}sub $sp,#2,$sp {le sp est décrémenté}jr $ra {retour}
L1: sub $a0,$a0,#1 {le paramètre est décrémenté}jal P3 {appel récursif}pop ($sp)-,$a0 {restauration de l'adresse depop ($sp)-,$ra { retour et du paramètre}mult $v0,$a0,$v0 {$v0 résultat}jr $ra {retour}
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
REGISTRESn = 3a0
a1a2a3
v0v1
ra adr+1
sp 1000
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
REGISTRESn = 3a0
a1a2a3
v0v1
ra adr+1
sp 1002
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
REGISTRESn = 2a0
a1a2a3
v0v1
ra L1+2
sp 1002
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
a0 = n = 2
RA = L1+2
REGISTRESn = 2a0
a1a2a3
v0v1
ra L1+2
sp 1004
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
a0 = n = 2
RA = L1+2
REGISTRESn = 1a0
a1a2a3
v0v1
ra L1+2
sp 1004
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
a0 = n = 2
RA = L1+2
a0 = n = 1
RA = L1+2
REGISTRESn = 1a0
a1a2a3
v0v1
ra L1+2
sp 1006
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
a0 = n = 2
RA = L1+2
REGISTRESn = 1a0
a1a2a3
v0 1v1
ra L1+2
sp 1004
1001
1002
1003
1004
1005
1006
1007
a0 = n = 1
RA = L1+2
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
REGISTRESn = 2a0
a1a2a3
v0 1*2 = 2v1
ra L1+2
sp 1002
1001
1002
1003
1004
1005
1006
1007
a0 = n = 2
RA = L1+2
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
a0 = n = 3
RA = adr+1
P3: push $ra,+($sp)push $a0,+($sp)bgt $a0,#1,L1move #1,$v0sub $sp,#2,$spjr $ra
L1: sub $a0,$a0,#1jal P3pop ($sp)-,$a0pop ($sp)-,$ramult $v0,$a0,$v0jr $ra
REGISTRESn = 3a0
a1a2a3
v0 2*3 = 6v1
ra adr+1
sp 1000
1001
1002
1003
1004
1005
1006
1007
....move #3,$a0
adr: jal P3......
Appel de procédure - Exemple IIIint P3 (int n) {
if (n<1)return (1);
elsereturn (n*P3(n-1));
}
1000
REGISTRESa0a1a2a3
v0 6v1
ra
sp 1000
1001
1002
1003
1004
1005
1006
1007
Le stack - Variables locales
Sauvegarde
$SP
Paramètres
Variableslocales
Adressede retour
Une dernière utilisation du stack consiste à stocker toutes les variables locales à une procédure qui sont trop grandes pour être stockées dans les registres.
Toutefois, quand le stack est utilisé pour stocker des variables locales, dont les tailles peuvent varier pendant l'exécution du programme (les variables locales ne sont pas forcement de la même taille pour chaque appel à une procédure donnée), il est parfois difficile d'utiliser le stack pointer pour référencer les informations dans le stack.
Appel de procédure - Le frame pointerAfin d'éviter cet inconvénient, certains processeurs (et/ou certains compilateurs) utilisent le frame pointer (fp), un registre qui contient l'adresse du premier mot du procedure frame (la portion du stack qui contient l'information relative à une procédure). À l'intérieur de la procédure, les informations contenues dans le frame sont référencées avec un déplacement (offset) par rapport au frame pointer.L’utilisation du frame pointer nécessite la présence dan le stack d’un pointer au frame pointer de la procédure précédente.
Sauvegarde
$SP
Paramètres
Adressede retour
Sauvegarde
Paramètres
Adressede retour
Variableslocales
Variableslocales
$FP
Blocprécédent
Blocprécédent
PC+PC+offset
Unité de contrôlePC+ adresse initiale
MAR PC+
MDR M[MAR]IR+ MDR
décodification de IR
PC+PC+1
saut?
contrôle?
adresse?
exécution
chargement
OUI
NONOUI
NONOUI
NON
CK
appel? NONOUI
SP+SP+1M[SP+]PC+1PC+Adresse
InterruptionsLes interruptions (interrupts ou exceptions ou traps ou aborts ou ...) sont des événements autres que les branchements qui changent le flot des instructions.Parmi les familles d'interruptions les plus courantes:
• requêtes des périphériques;• appels système par un programme utilisateur;• traces de l'exécution des instructions; • breakpoints (interruptions demandées par l'utilisateur);• overflow ou underflow arithmétiques;• page faults (page manquante en mémoire);• accès mémoire non alignés;• violations de protection mémoire;• utilisation d'une instruction non-définie;• mauvais fonctionnement du matériel;• pannes de courant.
InterruptionsLes interruptions sont traitées comme des appels de procédure: les procédures sont alors appelées des interrupt handling routines (routines de traitement des interruptions) et elles font partie intégrante de l'OS.
Dans la plupart des cas, le processeur doit pouvoir reprendre l'exécution du programme après le traitement d'une interruption. Cette obligation peut être extrêmement compliqué à mettre en œuvre (microprogrammation, instructions sur plusieurs mots, pipeline).
Malheureusement, les interruptions sont trop fréquentes pour les ignorer: on a estimé qu'une interruption survient en moyenne chaque milliseconde !
InterruptionsLes interruptions peuvent être analysées selon 5 critères:• Synchrone ou asynchrone. Une interruption peut être
asynchrone si elle est causée par un périphérique (donc, si elle est générée ni par le processeur ni par la mémoire) ou par le mauvais fonctionnement du matériel.
• Demandée par l'utilisateur ou imposée. L'utilisateur peut appeler certaines interruptions dans son programme.
• Masquable ou non-masquable. L'utilisateur peut forcer le programme à ignorer certaines interruptions.
• Pendant ou entre les instructions. Certaines interruptions surviennent pendant l'exécution d'une instruction et ne permettent pas à celle-ci de se terminer correctement.
• Permettant la reprise ou forçant la terminaison du programme.
Interruptions
Périphériques NON OUI NON OUI NONAppels système OUI NON NON OUI NONTraces d'exécution OUI NON OUI OUI NONBreakpoints OUI NON OUI OUI NONOverflow entier OUI OUI OUI NON NONOver/underflow flottant OUI OUI OUI NON NONPage faults OUI OUI NON NON NONAccès non alignés OUI OUI OUI NON NONViolations de protection OUI OUI NON NON NONInstruction non-définie OUI OUI NON NON OUIProblèmes matériels NON OUI NON NON OUIPannes de courant NON OUI NON NON OUI
Sync
hron
e
Impo
sée
Mas
quab
le
Ent
re in
str.
Fina
le