Architecture et technologie des ordinateurs II

Présentation au sujet: "Architecture et technologie des ordinateurs II"— Transcription de la présentation:

1 Architecture et technologie des ordinateurs II
Résumé Séquenceur CK Opcode Opérandes n BASCULES Fanions RAM Contrôle SLC Opérandes Instruction Adresse Adresse PC +1 CK + Offset Opcode SLC Condition Fanions G. Tempesti 1

2 Architecture et technologie des ordinateurs II
Résumé PC+  adresse initiale Mémoire Séquenceur CK Opcode Opérandes IR Fanions RAM Contrôle SLC Opérandes MDR MAR PC MAR  PC+ MDR  M[MAR] IR+  MDR CK décodification de IR OUI contrôle? NON OUI saut? NON NON adresse? OUI chargement exécution PC+PC+ offset PC+PC+1 G. Tempesti 2

3 Architecture et technologie des ordinateurs II
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 G. Tempesti 3

4 Architecture et technologie des ordinateurs II
Appel de procédure Une 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. G. Tempesti 4

5 Architecture et technologie des ordinateurs II
Appel de procédure Le 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. G. Tempesti 5

6 Appel de procédure - Exemple I
Architecture et technologie des ordinateurs II Appel de procédure - Exemple I Supposons 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} G. Tempesti 6

7 Appel de procédure - Exemple II
Architecture et technologie des ordinateurs II Appel de procédure - Exemple II Lors 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; } G. Tempesti 7

8 Appel de procédure - Le stack
Il 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.

9 Appel de procédure - Exemple II
int 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,$r0 add $a2,$a3,$r1 sub $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}

10 Appel de procédure - Le stack
$SP $R1 $R0 $SP $SP Avant Pendant Après

11 Architecture et technologie des ordinateurs II
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 Paramètres $SP $SP Avant Pendant Après G. Tempesti 11

12 Procédures imbriquées et récursives
Lors 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); else return (n * P3(n-1)); } Sauvegarde $SP Paramètres Adresse de retour

13 Appel de procédure - Exemple III
Pour cet exemple, on suppose que $a0 contient n. P3: push $ra,+($sp) {sauvegarde de l'adresse de push $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 de pop ($sp)-,$ra { retour et du paramètre} mult $v0,$a0,$v0 {$v0  résultat}

14 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 3 . move #3,$a0 adr: jal P3 1006 a1 a2 1005 a3 1004 v0 1003 v1 1002 ra adr+1 1001 1000 sp 1000

15 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 3 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 v0 1003 v1 1002 a0 = n = 3 ra adr+1 1001 RA = adr+1 1000 sp 1002

16 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 2 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 v0 1003 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1002

17 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 2 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 a0 = n = 2 v0 1003 RA = L1+2 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1004

18 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 1 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 a0 = n = 2 v0 1003 RA = L1+2 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1004

19 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 1 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a0 = n = 1 a1 a2 1005 RA = L1+2 a3 1004 a0 = n = 2 v0 1003 RA = L1+2 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1006

20 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 1 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a0 = n = 1 a1 a2 1005 RA = L1+2 a3 1004 a0 = n = 2 v0 1 1003 RA = L1+2 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1004

21 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 2 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 a0 = n = 2 v0 1*2 = 2 1003 RA = L1+2 v1 1002 a0 = n = 3 ra L1+2 1001 RA = adr+1 1000 sp 1002

22 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 n = 3 . move #3,$a0 adr: jal P3 P3: push $ra,+($sp) push $a0,+($sp) bgt $a0,#1,L1 move #1,$v0 sub $sp,#2,$sp jr $ra L1: sub $a0,$a0,#1 jal P3 pop ($sp)-,$a0 pop ($sp)-,$ra mult $v0,$a0,$v0 1006 a1 a2 1005 a3 1004 v0 2*3 = 6 1003 v1 1002 a0 = n = 3 ra adr+1 1001 RA = adr+1 1000 sp 1000

23 Appel de procédure - Exemple III
int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } REGISTRES 1007 a0 . move #3,$a0 adr: jal P3 1006 a1 a2 1005 a3 1004 v0 6 1003 v1 1002 ra 1001 1000 sp 1000

24 Le stack - Variables locales
Architecture et technologie des ordinateurs II Le stack - Variables locales 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. $SP Variables locales Sauvegarde Paramètres Adresse de retour G. Tempesti 24

25 Appel de procédure - Le frame pointer
Afin 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 Adresse de retour Variables locales $FP Bloc précédent

26 Architecture et technologie des ordinateurs II
Unité de contrôle PC+  adresse initiale MAR  PC+ MDR  M[MAR] IR+  MDR CK décodification de IR contrôle? OUI NON NON adresse? OUI OUI appel? NON chargement SP+SP+1 M[SP+]PC+1 PC+Adresse OUI saut? NON exécution PC+PC+ offset PC+PC+1 G. Tempesti 26

27 Interruptions Les 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.

28 Interruptions Les 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 !

29 Interruptions Les 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.

30 Interruptions Périphériques NON OUI NON OUI NON
Synchrone Masquable Entre instr. Imposée Finale Interruptions Périphériques NON OUI NON OUI NON Appels système OUI NON NON OUI NON Traces d'exécution OUI NON OUI OUI NON Breakpoints OUI NON OUI OUI NON Overflow entier OUI OUI OUI NON NON Over/underflow flottant OUI OUI OUI NON NON Page faults OUI OUI NON NON NON Accès non alignés OUI OUI OUI NON NON Violations de protection OUI OUI NON NON NON Instruction non-définie OUI OUI NON NON OUI Problèmes matériels NON OUI NON NON OUI Pannes de courant NON OUI NON NON OUI