La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Séquenceur CKCK n BASCULES Opcode Opérandes n BASCULES Opcode Opérandes Fanions RAM Contrôle SLC Opérandes Instruction Adresse CKCK Résumé CKCK Offset.

Présentations similaires


Présentation au sujet: "Séquenceur CKCK n BASCULES Opcode Opérandes n BASCULES Opcode Opérandes Fanions RAM Contrôle SLC Opérandes Instruction Adresse CKCK Résumé CKCK Offset."— Transcription de la présentation:

1 Séquenceur CKCK n BASCULES Opcode Opérandes n BASCULES Opcode Opérandes Fanions RAM Contrôle SLC Opérandes Instruction Adresse CKCK Résumé CKCK Offset SLC Opcode Condition Fanions +1 Adresse + PC

2 Résumé Mémoire Séquenceur CKCK IR Opcode Opérandes IR Opcode Opérandes Fanions RAM Contrôle SLC Opérandes MD R MA R CKCK PC PC + PC+ offset PC + PC+ offset PC + adresse initiale MAR PC + MDR M[MAR] IR + MDR MAR PC + MDR M[MAR] IR + MDR décodification de IR PC + PC+1 saut? contrôle? adresse? exécution chargement OUI NONOUI NONOUINON CK

3 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

4 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.

5 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.

6 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}

7 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; }

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 $SP $R0 AvantPendantAprès

11 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 Paramètres AvantPendantAprès

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 Sauvegarde 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} jr $ra{retour}

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

15 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra REGISTRES n = 3 a0 a1 a2 a3 v0 v1 ra adr+1 sp

16 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra REGISTRES n = 2 a0 a1 a2 a3 v0 v1 ra L1+2 sp

17 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra a0 = n = 2 RA = L1+2 REGISTRES n = 2 a0 a1 a2 a3 v0 v1 ra L1+2 sp

18 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra a0 = n = 2 RA = L1+2 REGISTRES n = 1 a0 a1 a2 a3 v0 v1 ra L1+2 sp

19 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra a0 = n = 2 RA = L1+2 a0 = n = 1 RA = L1+2 REGISTRES n = 1 a0 a1 a2 a3 v0 v1 ra L1+2 sp

20 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra a0 = n = 2 RA = L1+2 REGISTRES n = 1 a0 a1 a2 a3 v0 1 v1 ra L1+2 sp a0 = n = 1 RA = L1+2

21 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra 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 jr $ra 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 jr $ra REGISTRES n = 2 a0 a1 a2 a3 v0 1*2 = 2 v1 ra L1+2 sp a0 = n = 2 RA = L1+2

22 . move #3,$a0 adr:jal P3. move #3,$a0 adr:jal P3. Appel de procédure - Exemple III int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } int P3 (int n) { if (n<1) return (1); else return (n*P3(n-1)); } 1000 a0 = n = 3 RA = adr+1 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 jr $ra 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 jr $ra REGISTRES n = 3 a0 a1 a2 a3 v0 2*3 = 6 v1 ra adr+1 sp

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

24 Le stack - Variables locales Sauvegarde $SP Paramètres Variables locales Adresse de 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.

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. Lutilisation du frame pointer nécessite la présence dan le stack dun pointer au frame pointer de la procédure précédente. Sauvegarde $SP Paramètres Adresse de retour Sauvegarde Paramètres Adresse de retour Variables locales Variables locales $FP Bloc précédent Bloc précédent

26 PC + PC+ offset PC + PC+ offset Unité de contrôle PC + adresse initiale MAR PC + MDR M[MAR] IR + MDR 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+1 M[SP + ] PC+1 PC + Adresse SP + SP+1 M[SP + ] PC+1 PC + Adresse

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ériquesNONOUINONOUINON Appels systèmeOUINONNONOUINON Traces d'exécutionOUINONOUIOUINON BreakpointsOUINONOUIOUINON Overflow entierOUIOUIOUINONNON Over/underflow flottantOUIOUIOUINONNON Page faultsOUIOUINONNONNON Accès non alignésOUIOUIOUINONNON Violations de protectionOUIOUINONNONNON Instruction non-définieOUIOUINONNONOUI Problèmes matérielsNONOUINONNONOUI Pannes de courantNONOUINONNONOUI Synchrone Imposée Masquable Entre instr. Finale


Télécharger ppt "Séquenceur CKCK n BASCULES Opcode Opérandes n BASCULES Opcode Opérandes Fanions RAM Contrôle SLC Opérandes Instruction Adresse CKCK Résumé CKCK Offset."

Présentations similaires


Annonces Google