CHAPITRE II : MÉCANISMES DE
BASE D’EXÉCUTION DES
PROGRAMMES
[Link]
1. Machine de VON-NEUMANN
Définition
est un calculateur électronique à base de mémoire
dont les composants sont :
•Processeur ou Unité Centrale (UC) ; pour effectuer les
calculs et exécuter les instructions.
•Mémoire Centrale (MC).
•Unités périphériques ou d’Entrée/Sortie (E/S).
[Link]
1. Machine de VON-NEUMANN
Unité Centrale de Traitement (CPU, Central
Process Unit)
Appelée aussi "Processeur Central" (PC), elle
est composée de :
• L’Unité de Commande (UC).
• L’Unité Arithmétique et Logique (UAL).
• Les Registres (Données, Adresses, Contrôle,
Instruction).
• Bus Interne.
[Link]
Registres de l’unité de traitement(CPU) (1/4)
Est une mémoire temporaire (volatile) très
rapide
Compteur Ordinal (CO) (Programme Counter
(PC)):Contient l’adresse de la prochaine
instruction à exécuter. Non accessible au
programmeur.
Registre Instruction (RI) (Instruction Register
(IR))Contient l’instruction à décoder et à
exécuter.
[Link]
Registres de l’unité de traitement(CPU) (2/4)
Les Registres Généraux : permettent de faire le
calcul, la sauvegarde temporaire de résultats, Il s’agit
de :
• Registres Accumulateurs qui servent aux opérations
arithmétiques.
• Registres d’Index Utilisé pour l’adressage indexé. Contient
une adresse de référence et est très utile pour la
manipulation des tableaux.
• Registre de Base permet le calcul des adresses effectives.
contient l’@ de début du pgm permet la conversion d’1 @
logique à 1 @ physique
• Registres Banalisés stockage des résultats intermédiaires,
sauvegarde des informations fréquemment utilisées, …etc.
Ils permettent de limiter les accès à la mémoire, ce qui
accélère l'exécution d'un programme.
[Link]
Registres de l’unité de traitement(CPU) (3/4)
Registre pointeur de pile (PP): pointe vers la
tête de la pile du processeur.
Cette pile est réservée à l'usage de l'unité
centrale, en particulier pour sauvegarder les
registres et l'adresse de retour en cas
d'interruption ou lors de l'appel d'une
procédure. Le pointeur de pile est accessible
au programmeur, ce qui est souvent source
d'erreur.
[Link]
Registres de l’unité de traitement(CPU) (4/4)
Le Registre Mot d’Etat (PSW, Program Status
Word)
– Flags des bits utilisés dans les opérations arithmétiques
et comparaisons des opérandes.
– Le mode d’exécution:
• Mode privilégié ou maître (ou superviseur). Il
permet :
L’accès illimité aux données.
• Mode non privilégié ou esclave (ou usager):Il
permet :
Accès limité aux données d’usager.
– masque d’interruptions (seront détaillés dans la suite).
[Link]
2. Cycle d’exécution du processeur
E/S A
CPU Tc A Tc B Tc B Tc
1 2 3 4 5 6 7
[Link]
2. Cheminement d’un Programme dans un Système
[Link]
2. Cheminement d’un Programme dans un Système
[Link]
2. Cheminement d’un Programme dans un Système
[Link]
3. Concepts de Processus et de Multiprogrammation
• Un processus est un programme en cours
d’exécution.
• possède des caractéristiques propres (Ex. un
numéro d’identification), des ressources qu’il
utilise (comme des fichiers ouverts) et se
trouve à tout moment dans un état (en
exécution ou en attente …).
[Link]
3. Concepts de Processus et de Multiprogrammation
• Un processus est constitué d’ :
Un code exécutable du programme en
exécution.
Un contexte qui est une image décrivant
l’environnement du processus.
[Link]
3. Concepts de Processus et de Multiprogrammation
• Contexte d’un processus
ensemble des données qui permettent de
reprendre l’exécution d’un processus qui a été
interrompu. Il est formé des contenus de :
Compteur Ordinal (CO)
Mot d’état PSW
Registres généraux
Pile
CO + PSW = petit contexte
registres généraux + la pile =grand contexte.
[Link]
3. Concepts de Processus et de Multiprogrammation
• Image mémoire d’un processus
Code (Text) ; code des instructions du programme
à exécuter. lecture seulement (Read-Only).
Données (Data) ; qui contient l’ensemble des
constantes et variables déclarées.
Pile (Stack) ; qui permet de stocker
Les valeurs des registres,
Variables locales et paramètres de fonctions,
Adresse de retour de fonctions.
Tas (Heap) ; espace alloué dynamiquement en
cours d’exécution (Runtime), Expl: new et malloc.
[Link]
3. Concepts de Processus et de Multiprogrammation
Pile
Tas
Données
Code
Image mémoire d’un processus
[Link]
3. Concepts de Processus et de Multiprogrammation
• Descripteur de Processus (PCB Process Control Bloc). Il
peut contenir :
Identité du processus ; Un nom externe et Un nom
interne.
Etat du processus ;
Contexte du processus ; compteur ordinal, mot d’état,
registres.
Informations sur le scheduling de l’UC ; la priorité du
processus, …etc.
Informations sur la gestion mémoire ; inclure les
valeurs des registres base et limite.
Information sur l’état des E/S ; la liste de périphériques
d’E/S alloués à ce processus, …etc.
Informations de Comptabilisation ; l’utilisation des
ressources par le processus pour facturation du
travail effectué par la machine.
[Link]
3. Concepts de Processus et de Multiprogrammation
[Link]
3. Concepts de Processus et de Multiprogrammation
[Link]
• Prêt (Ready) : le processus attend la libération
du processeur pour s’exécuter.
• Actif (Running) : le processus est en
exécution.
• Bloqué (Waiting) : le processus attend une
ressource physique ou logique autre que le
processeur pour s’exécuter (mémoire, fin
d’E/S, …etc.).
[Link]
Etats du processus
Nouveau Terminé
Admis Allocation CPU Exit
Prêt Actif
Réquisition CPU
Fin E/S demE/S
Bloqué
Diagramme de transition des états d’un processus
[Link]
Multiprogrammation
• le processeur assure l’exécution de plusieurs
processus en parallèle (pseudo-parallélisme).
• Le passage dans l’exécution d’un processus à
un autre nécessite une opération de
sauvegarde du contexte du processus arrêté,
et le chargement de celui du nouveau
processus. Ceci s’appelle la commutation du
contexte (Context Switch).
[Link]
Multiprogrammation
• Mécanisme de commutation de contexte
La commutation de contexte consiste à
changer les contenus des registres du
processeur central par les informations de
contexte du nouveau processus à exécuter.
[Link]
Multiprogrammation
[Link]
Multiprogrammation
• La commutation du contexte se fait en deux
phases :
• La première phase consiste à commuter le
petit contexte (CO, PSW) par une instruction
indivisible.
• La deuxième phase consiste quant à elle à
commuter le grand contexte par celui du
nouveau processus.
[Link]
Multiprogrammation
[Link]
Multiprogrammation
• Remarque
La commutation du contexte est
déclenchée suivant l’état d’un indicateur qui
est consulté par le processeur à chaque point
observable.
[Link]
Processus sous UNIX
• Identification d’un processus
Un processus est identifié de manière unique
par un numéro (pid: Process IDentifier).
[Link]
Processus sous UNIX
• La commande ps (voir man ps) donne la liste des
processus en cours d’exécution avec leurs
propriétés (identifiant du processus, identifiant
du processus père, taille, priorité, propriétaire,
état, etc.)
• La fonction getpid() indique le numéro du
processus qui l’exécute
#include <sys/types.h>
#include <unistd.h>
pid_t getpid(void);
[Link]
Processus sous UNIX
• Création d’un processus
• Fork(). Le processus créé (le fils) est un clone
(copie conforme) du processus créateur (le
père).
• #include <sys/types.h>
• #include <unistd.h>
• pid_t fork(void);
• ...
[Link]
Processus sous UNIX
• La fonction fork permet la création dynamique d'un
nouveau processus qui s'exécute de façon
concurrente avec le processus qui l'a créé.
• Un appel à fork() par un processus, appelé processus-
père, demande à UNIX de mettre en activité un
nouveau processus (appelé processus-fils) qui est une
copie conforme du processus courant, pour la plupart
de ses attributs.
• Cette fonction rend : • -1 en cas d’échec, • 0 dans le
processus fils, • Le pid du processus fils dans le père.
[Link]
Processus sous UNIX
• Le père (Parent) et le fils (Child) ne se
distinguent que par le résultat retourné par
fork. Pour le père, cette fonction renvoie le
numéro du fils (ou -1 si création impossible)
et pour le fils, elle renvoie 0.
[Link]
Processus sous UNIX
• Exemple
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
case 0: /* Programme du fils */
...
default: /* Programme du père */
[Link]
Processus sous UNIX
Pcb-pere pidp
Tas
Pile
données
fork() code
IM_pére
[Link]
Processus sous UNIX
pidp pid
Pcb_pére Pcb_fils
Tas Tas
pile pile
Pid=pidF Pid=0
code code
IM_pére IM_fils
[Link]
Processus sous UNIX
• Hiérarchie des processus
La commande UNIX ps -aeH permet d’afficher
la hiérarchie complète des processus, y
compris le processus init.
[Link]
Processus sous UNIX
• Terminaison d’un processus(1/5)
Dans des conditions normales, un processus
peut se terminer de deux façons:
• Soit la fonction main du programme se
termine,
• Soit le programme appelle la fonction exit.
#include <stdlib.h>
void exit (int status);
[Link]
Processus sous UNIX
• Terminaison d’un processus(2/5)
l’envoi d’un signal du type kill. Ceci peut se
faire de deux façons :
• Soit à partir d’un programme, en utilisant la
fonction kill().
#include <sys/types.h>
#include <signal.h>
int kill (pid_t pid, int sig);
[Link]
Processus sous UNIX
• Terminaison d’un processus(3/5)
kill() envoie le signal numéro sig à un
processus identifié par son pid. En cas d'erreur
elle retourne -1, et 0 autrement.
[Link]
Processus sous UNIX
• Terminaison d’un processus(4/5)
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
case 0: /* Programme du fils */
...
default: /* Programme du père */
...
/*Envoi d’un signal de terminaison au fils*/
kill(pid, SIGTERM);
}
[Link]
Processus sous UNIX
Terminaison d’un processus(5/5)
Soit à partir du shell, en invoquant la
commande kill.
$ kill pid
• La commande kill envoie par défaut un signal
SIGTERM, ou de terminaison au processus
d’identité pid.
[Link]
Processus sous UNIX
Code de sortie d’un processus(1/2)
(Exit Code) : un nombre que le processus renvoie
à son parent. Le code de sortie est l'argument
passé à la fonction exit ou la valeur retournée
depuis main.
Par convention, le code de sortie est utilisé pour
indiquer si le programme s'est exécuté
correctement :
– Un code de sortie à zéro indique une exécution
correcte,
– Un code différent de zéro indique qu'une erreur est
survenue.
[Link]
Processus sous UNIX
Code de sortie d’un processus(2/2)
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
exit(1);
case 0: /* Programme du fils */
...
exit(0);
default: /* Programme du père */
...
}
[Link]
Processus sous UNIX
La fonction wait()
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait (int* statut);
[Link]
Processus sous UNIX
La fonction wait()
• Lorsque le fils se termine, si son père ne
l’attend pas, le fils passe à l’état zombie dans
la table des processus.
• L’élimination d’un processus terminé de la
table ne peut se faire que par son père, grâce
à la fonction wait().
[Link]
Processus sous UNIX
La fonction wait()
• Le père se bloque en attente de la fin d’un
fils.
• Elle rendra le pid du premier fils
mort(terminé) trouvé.
• La valeur du code de sortie est reliée au
paramètre d’exit de ce fils.
[Link]
Processus sous UNIX
La fonction wait()
• On peut donc utiliser l’instruction wait() pour
connaître la valeur éventuelle de retour,
fournie par exit(), d’un processus.
• Ce mode d’utilisation est analogue à celui
d’une fonction.
[Link]
Processus sous UNIX
La fonction wait()
• wait() rend –1 en cas d’erreur.
• Un processus exécutant l'appel système wait()
est endormi jusqu'à la terminaison d'un de ses
fils.
• Lorsque cela se produit, le père est réveillé et
wait() renvoie le pid du fils qui vient de
terminé.
[Link]
Processus sous UNIX
La fonction wait()
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
case 0: /* Programme du fils */
printf("processus fils %d\n", getpid());
exit(10);
default: /* Programme du père */
printf("processus père %d\n", getpid()) ;
pid_t id = wait (&status);
printf("fin processus fils %d\n", id);
exit(0);
}
[Link]
Processus sous UNIX
La fonction waitpid()
#include <sys/types.h>
#include <sys/wait.h>
pid_t waitpid (pid_t pid , int* statut , int options);
[Link]
Processus sous UNIX
La fonction waitpid()
• L’appel système waitpid() permet de tester la
terminaison d’un processus particulier, dont
on connaît le pid.
• La primitive permet de tester, en bloquant ou
non le processus appelant, la terminaison d’un
processus particulier ou appartenant à un
groupe de processus donné et de récupérer
les informations relatives à sa terminaison à
l’adresse terminaison.
[Link]
Processus sous UNIX
La fonction waitpid()
int waitpid (int pid, int *status, int options)
• Le paramètre pid permet de sélectionner le
processus attendu de la manière suivante :
<-1 tout processus fils dans le groupe | pid |
-1 tout processus fils ( un de ses fils)
0 tout processus fils du même groupe que l’appelant
> 0 processus fils d’identité pid.
[Link]
Processus sous UNIX
La fonction waitpid()
int waitpid (int pid, int *status, int options)
• Le paramètre options est une combinaison bit à
bit des valeurs suivantes:
– La valeur WNOHANG permet au processus appelant de
ne pas être bloqué si le processus demandé n’est pas
terminé.
– La valeur 0 permet une attente bloquante
[Link]
Processus sous UNIX
La fonction waitpid()
int waitpid (int pid, int *status, int options)
• La fonction renvoie :
-1 en cas d’erreur,
0 en cas d’échec (processus demandé existant mais non
terminé) en mode non bloquant.
[Link]
Processus sous UNIX
La fonction waitpid()
pid_t id;
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
case 0: /* Programme du fils */
...;
exit(10);
default: /* Programme du père */
...
While((id=waitpid(pid,&status,WNOHANG))==0)
printf("processus fils non encore terminé\n");
printf("fin processus fils %d\n", id) ;
...
}
[Link]
Processus sous UNIX
Code de sortie retourné par wait() et waitpid()
• Si le processus fils c’est terminé normalement,
son code de retour peut être extrait.
• WIFEXITED(status), renvoie vrai si le processus
fils c’est terminé normalement.
• Ensuite pour obtenir son code de retour, la
macro WEXITSTATUS(status) est utilisée.
[Link]
Processus sous UNIX
Code de sortie retourné par wait() et waitpid()
pid_t id;
pid_t pid=fork();
switch(pid){
case -1: /* Erreur de création */
...
case 0: /* Programme du fils */
...;
exit(10);
default: /* Programme du père */
...
while((id=waitpid(pid,&status,WNOHANG))==0)
printf("processus fils non encore terminé\n");
if(WIFEXITED(status))
printf("fils %d terminé par exit(%d)\n",id,WEXITSTATUS(status));
...
}
[Link]
