CHAP2

Chapitre 2 :
Les processus
MAHDI HERMASSI
1
Système multitâche (1)
Système d’exploitation multitâche
• Un système d’exploitation est multitâche, s’il permet d’exécuter, de façon
apparemment simultanée, plusieurs programmes utilisateur.
• La simultanéité est le résultat de l’alternance rapide d’exécution des processus
présents en mémoire (notion de temps partagé et de multiplexage).
• Partage des ressources matérielles : CPU, RAM, périphérique.
2
Système multitâche (2)
Problèmes
• Un microprocesseur n'est prévu pour exécuter un seul programme a la fois.
• On veut exécuter plusieurs programmes qu'il n’y a moins des microprocesseurs.
• L’exécution d’un programme ne doit pas perturber celle des autres.
3
Exécution d’un programme (1)
Propriétés
• Chaque exécution d’un programme donne lieu a un processus diffèrent.
• A tout instant, un microprocesseur exécute au plus un seul processus.
• Le système alterne entre l'exécution de plusieurs processus.
• Les processus partagent l'accès a différentes ressources (CPU, RAM, périphériques).
4
Exécution d’un programme (1)
• Le système doit charger le code binaire du programme de mémoire vive.
• Trouver son point d'entrée d'exécution (Fonction main ()).
• Suivre son déroulement a travers les adresses d’instructions (Pointeur d’instruction).
• Terminer l'exécution du programme et libère les ressources qu'il occupait.
5
Processus (1)
• Un processus est un programme en cours d'exécution.
• Un processus est géré par le noyau comme une structure de donnée qui
contient toutes les informations nécessaires afin de suivre le déroulement
du programme, den mettre en pause ou den reprendre d'exécution.
6
Processus (2)
Microprocesseur
Dans le microprocesseur, a un instant donnée, un processus est décrit par :
• Les valeurs contenues dans les registres : compteur de programme, registre
généraux, registre d’états et le pointeur de pile.
• L'Etat de l’espace mémoire qui lui a été attribuer par le système d’exploitation.
7
Processus (3)
Mémoire vive
A un instant donnée, un processus dans la mémoire est caractérisée par :
• Code : un espace mémoire qui contient les instructions binaires.
• Données : un espace mémoire pour les données allouées par le processus (programme).
• Pile ou stack : un espace mémoire pour les variables locales et la gestion des appels et
retour des fonctions.
• Tas ou heap : espace mémoire pour les allocations dynamiques qui sont créer au
moment de l’exécution.
8
Processus (4)
Processus en mémoire
9
Processus (5)
Mode d’exécution
Mode d’exécution d’un processus
Il y a deux modes d’exécution d’un processus:
• Mode noyau : accès sans restriction : manipulation de la mémoire, dialogue avec les
contrôleurs de périphérique .
• Mode utilisateur : accès restreint, certaines instructions sont interdites. Il peut être
interrompu par d’autre processus.
10
Processus (6)
Commutation de processus
Commutation de processus
• La passage de l'exécution d'un processus a un autre est la communication de processus
(changement de contexte)
• L'idée est de faire progresser l'exécution de plusieurs processus cœurs.
• La communication permet d’exploiter le temps requis pour effectuer des
entrées/sorties, l'exécution simultanée de plusieurs processus.
11
Processus (7)
Propriétés d’un processus
Du point de vue du système, un processus est décrit par :
• Ses identificateurs : (UID, PID, PPID)
• Sont état (en exécution, prêt, suspendu, terminé).
• Son bloc de contrôle de processus : « PCB ».
• Son compteur ordinal : indique la prochaine instruction a exécuter.
• Ses données en mémoire
• Les ressources qu'il utilise (fichiers, registres).
12
Processus (8)
Identificateurs de processus
Sous le système UNIX, il y a plusieurs identificateurs sont associes a un processus :
• Un processus est identifié au niveau système, par un entier unique : le PID pour
Process IDentifier.
• Chaque processus possède un père créateur, il possède un accès a l’identifiant de leur
père : le PPID, pour Parent Process IDentifier.
• Chaque processus possédé un utilisateur propriétaire: le UID, pour User IDentifier,
qui est utilisé par le système pour déterminer ses permissions d’accès aux ressources
(fichiers, matériels).
13
Processus (8)
état d’un processus
Un processus est caractérisé par différentes états d’exécution :
• Elu : lorsque le processus obtient le microprocesseur et s'exécute.
• Bloqué : lorsque le processus demande accès a une ressource indisponible.
• Prêt : le processus a été charge dans la mémoire, en attente d'accès au microprocesseur.
• Terminé : le processus a pu terminer son code exécution par le microprocesseur.
14
Processus (8)
15
Processus (8)
États particuliers
Un processus est caractérisé par des états particuliers :
• Un processus est orphelin lorsque son père s’est termine son exécution.
• Un processus est zombie lorsqu'il est terminé l'exécution et son père en vie. Il dispose
encore d'un numéro PID en mémoire et un PCB système.
• Un processus daemon qui s'exécute en arrière-plan sous le contrôle direct d'un noyau.
Il est démarré lors du chargement du système d’exploitation pour répondre a des requetés
du réseau, a l'activité du matériel ou a d'autres programmes de mise a jour logicielle.
16
Processus (9)
Bloc de contrôle de processus
• Le Processus Control Block est une structure de donnée au niveau système qui contient
toutes les informations nécessaires a la bonne exécution d'un processus.
• Elle contient la priorité, l'état , les fichiers ouverts, les identificateurs d’un processus, les
addresses e compteur ordinal, code, données et pile, qui sont tous stockés dans un table
système des processus.
• A partir de PCB d’un processus, le système peut faire reprendre l’exécution, ou arrêter
son exécution.
17
Processus (9)
18
Processus (9)
Structure arborescente
Sous le système Unix, les processus sont organisés de façon arborescente:
• A la racine de l'arbre, il y a l’ancêtre de tous les processus : qui s'appelle systemd.
• Son numéro PID égal a 1 et son numéro PPID égal a 0.
19
Programmation de processus (1)
Création de processus
Un processus peut être crée a différentes moments d’utilisation :
• Initialisation du système.
• Appel système de création de processus
• Demande de l'utilisateur.
20
Unix appel système fork()
Dans le système Unix, un nouveau processus est forcement le résultat de copie d'un
processus existant :
• Le processus existant est appelé le père.
• Le nouveau processus créé est appelé le fils.
• La création d’un nouveau processus se réalise avec un appel système fork().
• Le processus fils représente une copie exacte du processus père (Mémoire de
données, pile et code).
21
Appel système
• Un appel système consiste a changer le mode d'exécution pour passer du
mode utilisateur au mode noyau (Système), récupère les paramètres et
vérifier la validité de l’appel, puis lancer l'exécution de la fonction
demandée.
22
#include <unistd.h>
pid_t fork();
La valeur de retour de la fonction fork() permet de se distinguer entre le fils et le père :
• En cas de succès, le numéro de PID du fils dans le code de programme père et une
valeur zéro dans le code du programme fils.
• En cas d’échec, la valeur -1 dans le code du programme pére.
23
#include <stdio.h>
#include <unistd.h>
int main(){
pid_t p=fork():
if (p==-1) printf(‘’Echec de création dun processus ’’);
else if (p==0) printf(‘’Je suis le processus fils’’);
else printf(‘’Je suis le processus pére’’);
return 0; }
24
• Les processus fils et père sont identiques, mais ils ont un PCB système différent.
• Le processus fils peut s’exécuter parallèlement à son père.
• Chaque processus peut savoir son numéro PID et le numéro PPID de son parent.
• Les fonctions système getpid() et getppid revoient les identifiants PID et PPID d’un
processus donnée.
• La fonction système getuid() revoie l’identifiant de l’utilisateur propriétaire d’un
processus donnée.
25
#include <stdio.h>
#include <unistd.h>
int main(){
p=fork();
if (p==-1) printf(‘’Echec de création dun processus ’’);
else if (p==0) printf(‘’Le fils PID=%d PPID=%d’’,getpid(),getppid());
else printf(‘Le père PID %d PPID=%d’’, getpid(),getppid());
return 0; }
26
exécution d’un processus
Une fois qu'un nouveau processus a été créé, il est souvent nécessaire de
charger et d'exécuter un nouveau code programme à l'intérieur de ce
processus. Cela peut être accompli en utilisant la fonction exec(), aussi,
lorsqu'un processus est interrompu ou suspendu en raison d'une erreur ou d'une
panne système, le système d'exploitation peut tenter de le recouvrer en
redémarrant le processus ou en tentant de le relancer à partir d'un point de
sauvegarde précédent. Dans ce cas, la fonction exec() peut être utilisée pour
créer un nouveau processus en exécutant le même programme que le
processus interrompu ou suspendu.
27
Il existe plusieurs variantes de la fonction exec(), chacune ayant une utilisation spécifique
pour préciser le chemin d'accès du programme à exécuter.
 execv() : Cette fonction prend deux arguments, le chemin d'accès complet du
programme à exécuter et un tableau d'arguments à passer au nouveau programme.
 execl() : Cette fonction est similaire à execv(), mais les arguments sont passés
individuellement en tant que paramètres à la fonction.
 execvp() : Cette fonction utilise la variable PATH pour rechercher le programme à
exécuter. Elle prend deux arguments, le nom du programme à exécuter et un tableau
d'arguments à passer au nouveau programme.
 execlp() : Cette fonction est similaire à execvp(), mais les arguments sont passés
individuellement en tant que paramètres à la fonction.
28
Remplacement en précisant le chemin
• int execv (const char*path, char *const argv[]);
• int execl (const char*path, const char *arg[]);
Le premier argument est une chaîne de caractères Le deuxième argument est un tableau de pointeurs vers
qui contient le chemin d'accès au programme à des chaînes de caractères, qui représente les arguments
exécuter. Le chemin d'accès peut être absolu (par passés au programme que vous voulez exécuter. Le
exemple, "/chemin/vers/monprogramme") ou relatif tableau doit être terminé par un pointeur nul (NULL).
(par exemple, "./monprogramme" pour exécuter un
programme se trouvant dans le répertoire courant).
29
Remplacement en précisant le chemin
• int execvp (const char*file, char *const argv[]);
• int execlp (const char*file, const char *arg[]);
le nom du programme à exécuter (file) un tableau de pointeurs de chaînes de caractères (argv)

qui contient les arguments à passer au programme. Le
tableau argv doit être terminé par un pointeur NULL.
30
Remplacement de code en précisant le chemin.
• char *code[] = {‘cat’, ‘-n’, ‘/etc/passwd’, NULL};
• execv (‘/bin/cat’, code);
• execl (‘/bin/cat’, ‘cat’, ‘-n’, ‘/etc/passwd’, NULL);
31
Remplacement de code avec la variable PATH.
• char *code[] = {‘cat’, ‘-n’, ‘/etc/passwd’, NULL};
• execvp (‘cat’, code);
• execlp (‘cat’, ‘cat’, ‘-n’, ‘/etc/passwd’, NULL);
32
#include <stdio.h>
#include <unistd.h>
int main() {
pid_t p = fork();
if (p == -1) { printf("Echec de création d'un processus \n"); }
else if (p == 0) { printf("Je suis le fils \n");
execlp("date", "date", "+%T", NULL); }
else { printf("Je suis le père\n");
execlp("cal", "cal", "2022", NULL); }
return 0; }
33
Terminaison de processus
Un processus peut être terminé de différentes manières : d’une façon
normale volontaire, façon volontaire suite à une erreur, façon
involontaire suite à une erreur grave, ou bien terminer par un autre
processus.
Si le processus a pu terminer, les ressources allouées sont libérées et
son bloc de contrôle PCB sont détruit par le système.
34
La terminaison volontaire est signale par un appel système à la fonction : exit(int
n).
o #include <stdlib.h>
o voit exit(int n);
Il y aura une destruction du processus actuel par un code entier 0 en cas de
succès, une autre valeur négative en cas d’échec.
35
La terminaison par un autre processus se fait par un envoi de signal système par
la fonction : kill ( int pid, int SIG).
o #include <signal.h.>
o kill (int PID, int SIG);
Elle va envoyer un type de signal SIG vers un processus dont le numéro est PID.
Le signal peut être SIGTERM fait terminer le processus.
Le signal peut être SIGKILL fait arrêter le processus d’une façon sure.
36
Un signal est une alerte qui stoppent l’exécution du processus.
C’est un simple message modélisé par un entier pour envoyer d’un processus à
un autre pour se communiquer.
Le signal est asynchrone ou peut arriver a son destination n’importe quand. Il
existe un petit nombre de messages prédéfinis :
o Constante SIGINT = 2 ( touches clavier Ctrl+C),
o Constante SIGSTOP = 19 (touches clavier Ctrl+Z)
o Constante SIGKILL = 9 (kill)
o Constante SIGSEGV = 11 (erreur de segmentation)
37
Suspension de processus
Arrêter momentanément l ’exécution d’un processus pour la
reprendre ultérieurement, le contexte du processus est sauvegardé
dans son « PCB » système et le processus passe dans l’état bloqué.
o #include <unistd.h>
o void sleep (int S);
La fonction système sleep (int s) permet de suspendre (bloquer)
l’exécution d’un processus appelant pour une durée de S secondes. Le
processus est réveillé par l’envoi du signal SIGALRM au bout de S
secondes.
38
o #include <sys/wait.h>
o int wait(0);
La fonction système wait(0) dans le processus père provoque la
suspension du processus appelant jusqu’à ca que l’un de ses
processus fils se termine ou jusqu’à l’occurrence d’un signal émis
vers le processus appelant.
S’il n’existe aucun fils alors le retour de l’appel est immédiat et la
valeur de retour est -1.
39
o #include <sys/wait.h>
o int waitpid(int PID, int *etat, int opt);
La fonction système waitpid (int PID, int *etat, int opt); permet d’attendre qu’un seul
processus fils désigné par son PID se termine, et de récupérer éventuellement son code
de retour.
 PID est le numéro du fils qu’on attend, ou valeur 0 si n’importe quel processus.
 etat permet de récupérer les informations de retour du fils;
 Si opt est à 0 alors l’attente est bloquante;
 Si opt est à la constante WNOHANG, l’appel retourne immédiatement (non
bloquante).
40
Exercice 1
Ecrire un programme en C qui crée un processus enfant. Le processus
enfant doit afficher le message "Bonjour, je suis le processus enfant"
et se terminer. Le processus père doit s'endormir pour 5 secondes,
puis envoyer un signal au processus enfant pour le réveiller. Le
processus enfant doit alors afficher le message "Le processus enfant a
reçu le signal" et se terminer.
Correction
41
Communication entre processus
Les signaux constituent un moyen de communication entre processus,
mais ils ne permettent pas d’échanger des données.
Les tubes (PIPE) sont un mécanisme de communication entre
processus résidants sur une mémé machine. Ils sont implantés sous
forme des fichiers.
42
Un tube peut être vu comme un canal dans lequel un processus, à une
extrémité, produit des informations, tandis qu’à l’autre extrémité un
autre processus les consomme.
int fd[2];
pipe(fd);
Ecriture Lecture
fd[1] Tube (PIPE) fd[0]
43
Les tubes fournissent un canal de communication unidirectionnel :
 Ils ont une extrémité d’écriture et une de lecture.
 Ils ont une taille limitée et peuvent être remplis.
 Ils n’ont pas de nom et doivent donc être partagés des la création.
 Le processus lecteur forme le descripteur en écriture du tube.
 Le processus rédacteur ferme le description en lecture du tube.
44
Un tube est crée par l’appel système pipe(int descripteur[2]) qui
remplit le tableau descripteur avec les descripteurs de chacune des
extrémités du tube : l’entrée en lecture seule et la sortie en écriture
seule.
 Fonction write (fd[1]) permet d’écrire des données en mode octets
sur le descripteur numéro 1.
 Fonction read (fd[0]) permet de lire des données en mode octets
sur le descripteur numéro 0.
 Fonction close(descripteur) permet de fermer un descripteur sur le
tube.
45
Exemple
#include <stdio.h> processus fils\n"); else { // Code du processus père
#include <unistd.h> return 1; } close(fd[1]); // Ferme le
descripteur d'écriture du tube
int main() { else if (pid == 0) { // Code du
processus fils int valeur;
int fd[2];
close(fd[0]); // Ferme le read(fd[0], &valeur,
if (pipe(fd) == -1) { descripteur de lecture du tube sizeof(valeur)); // Lit la valeur depuis
printf("Erreur de création du le tube
int valeur = 42;
tube \n"); close(fd[0]); // Ferme le
write(fd[1], &valeur, descripteur de lecture du tube
return 1; } sizeof(valeur)); // Écrit la valeur 42
pid_t pid = fork(); dans le tube printf("La valeur lue depuis le
tube est : %d\n", valeur); }
if (pid == -1) { close(fd[1]); // Ferme le
descripteur d'écriture du tube } return 0;}
printf("Erreur de création du
46
Exercice 2
Écrire un programme qui crée deux processus fils. Le premier
processus doit exécuter la commande ls -l en utilisant la fonction
execlp(). Le deuxième processus doit exécuter la commande ps -ef en
utilisant la fonction execlp(). Les deux processus doivent
communiquer via un tube, de sorte que le deuxième processus reçoit
en entrée la liste des fichiers affichés par le premier processus et les
affiche à l'écran.
Correction
47

CHAP2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CHAP2

Transféré par

Droits d'auteur :

Formats disponibles

Chapitre 2 :

le nom du programme à exécuter (file) un tableau de pointeurs de chaînes de caractères (argv)

Vous aimerez peut-être aussi