1 / 30

Résumé

Adresse. CK. Instruction. Séquenceur. SLC. n BASCULES Opcode Opérandes. Opérandes. RAM. Contrôle. CK. Fanions. Résumé. Adresse. PC. +1. CK. +. Offset. Opcode. SLC. Condition. Fanions. Mémoire. MDR. MAR. CK. PC. Séquenceur. SLC. IR Opcode Opérandes. Opérandes. RAM.

bryanne-kennedy
Download Presentation

Résumé

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

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

  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 $R0 $SP $SP Avant Pendant Aprè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 Paramètres $SP $SP Avant Pendant Après

  12. Sauvegarde $SP Paramètres Adresse de retour Sauvegarde Paramètres Adresse de retour 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)); • }

  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. 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 jr $ra 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 jr $ra 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 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 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 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 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 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 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 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 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 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 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 jr $ra 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 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

  25. Variables locales $SP Sauvegarde Paramètres Adresse de retour Bloc précédent $FP Variables locales Sauvegarde Paramètres Adresse de retour Bloc précédent 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.

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

  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. Synchrone Imposée Masquable Entre instr. 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

More Related