2.FSTM SE-Processus

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 60

Université HASSAN II – Casablanca -

Faculté des Sciences et Techniques -Mohammedia -

Filière :
Ingénierie Logicielle
et Intégration des Systèmes Informatiques (ILISI)

Module :
Systèmes d’Exploitation
(Operating System)
C. Leghris Systèmes d’exploitation 1
Les
Processus

C. Leghris Systèmes d’exploitation 2


Les processus
 Plan :
 Définitions ;
 Exclusion mutuelle ;
 Synchronisation entre processus ;
 Les processus sous Unix ;

C. Leghris Systèmes d’exploitation 3


Les processus

 Plan :
 Définitions ;
 Exclusion mutuelle ;
 Synchronisation entre processus ;
 Les processus sous Unix ;

C. Leghris Systèmes d’exploitation 4


Les processus
 Définitions :
 Processus
 Entité dynamique représentant l'exécution d'un
programme ;
 Un processus naît, vit et meurt ;
 Il représente l’exécution concurrente de tâches au sein
d’un système d’exploitation ;
 Un processus :
- Partage des données ou des ressources matérielles ;
- Echange des signaux ou des informations ;
- Arrête ou tue autres processus ;
- etc ;

C. Leghris Systèmes d’exploitation 5


Les processus
 Définitions :
 Processus
 Un processus est défini par :
• Son code du programme ;
• Ses données du programme ;
• Son contexte d'exécution (vecteur d'état) à savoir :
- Les informations qu'il utilises explicitement (variables, procédures,
ressources, etc.) ;
- Les informations utilisées par le système pour gérer l'attribution des
ressources (contenus des registres, taille mémoire utilisée, ressources
matérielles utilisées) ;

C. Leghris Systèmes d’exploitation 6


Les processus
 Définitions :
 Processus
 Un processus ne pouvant être créé qu’au moyen d’un
autre processus ayant réalisé l’appel ;
 On voit apparaître naturellement les notions :
- Arborescence des processus, à partir d’un ancêtre commun à
tous (INIT sous le SE UNIX) ;
- Groupes de processus (process groups), définis comme étant
des sous-arborescences ;
 Avantage :
Limiter la portée des commandes de contrôle de processus (par
exemple la commande kill sous Unix) ;

C. Leghris Systèmes d’exploitation 7


Les processus
 Définitions :
 Instruction
 C’est une séquence unique d’un programme dont la
nature est fonction du langage de programmation
utilisé ;
 Elle est considérée comme indécomposable
(indivisible) ;
 Processeur
 Le processeur est l'entité capable d'exécuter
une instruction ;

C. Leghris Systèmes d’exploitation 8


Les processus
 Définitions :
 Ressource
 Entité pouvant servir à l'exécution d'un travail ;
 Exemples :
- Processeur, mémoire centrale, périphériques ;
- Fichiers, données …, etc ;
 Un processus est dans un état bloqué s'il lui manque
des ressources pendant son exécution de sa prochaine
instruction ;
• Sinon, il actif ;
• Deux types de blocage possibles ;

C. Leghris Systèmes d’exploitation 9


Les processus
 Définitions :
 Ressource
 Types de blocage possibles :
• Technologique pour l'absence de ressources ;
• Intrinsèque pour un problème de synchronisation ;
 Plusieurs processus en même temps = ils sont parallèles ;
 Il y a deux sortes de parallélisme :
• Le parallélisme vrai, où n processus s'exécutent sur m processeurs
(architecture multiprocesseurs) ;
• Le parallélisme simulé, où n processus s'exécutent sur un seul
processeur qui est successivement attribué à chacun ;

C. Leghris Systèmes d’exploitation 10


Les processus
 Définitions :
 Ressource
 Une ressource peut être :
• Locale à un processus s'il est le seul à pouvoir l'utiliser ;
• Globale si elle n'est locale à aucun processus ;
• Partageable avec n points d'accès si elle peut être attribuée, au
même instant, à n processus au plus ;
 Une ressource partageable avec un point d'accès est
dite critique (processeur, imprimante …) ;
 On appelle section critique d'un processus, la phase du
processus pendant laquelle la ressource critique est
utilisée par ce processus ;
C. Leghris Systèmes d’exploitation 11
Les processus
 Définitions :
 Ressource
 Les processus peuvent entrer en compétition pour
l'accès à une ressource ou fonctionner en coopération ;
 Dans la situation de parallélisme vrai ou simulé, dès que
plusieurs processus partagent une ressource en
commun, l'ordre dans lequel ils s'exécutent n'est pas
indifférent ;
• Le problème de synchronisation et de communication
entre les processus s’impose ;
 On appelle section critique, la partie d’un programme
où se produit le conflit d’accès ;
C. Leghris Systèmes d’exploitation 12
Les processus
 Définitions :
 Etats d’un processus
 Elu :
- En cours d’exécution sur le processeur ;

- Plusieurs processus peuvent être élus en même temps, mais il y a


toujours au plus, autant de processus élus que de processeurs ;
 Prêt :
- Il est suspendu en faveur d’un autre ;

- Un processus est prêt s’il ne lui manque que la ressource


processeur pour s’exécuter ;
 Bloqué :
- Il est en attente d’un événement externe (bloc disque, frappe
clavier, …) ;
C. Leghris Systèmes d’exploitation 13
Les processus
 Définitions :
 Etats d’un processus

1: Il a épuisé le quantum du
Elu
temps qui lui a été attribué ;
2 2 : L’ordonnanceur élit ce
processus parmi ceux prêts ;
3 3 : Le processus s’endort en
1
attendant un événement
Prêt externe ( décompte d’horloge,
données … ) ;
4
4 : L’événement attendu par le
Bloqué processus est arrivé ;

C. Leghris Systèmes d’exploitation 14


Les processus

 Plan :
 Définitions ;
 Exclusion mutuelle ;
 Synchronisation entre processus ;
 Les processus sous Unix ;

C. Leghris Systèmes d’exploitation 15


Les processus
 Exclusion mutuelle
 Problème qui se pose lorsqu'une ressource critique est
nécessaire à la continuation de plusieurs processus ;
 Exemple :
compte_utilise = FAUX ;
compte_client = 1000 ;
/* corps du programme du processus i */
derniere_facture = m ; i

while (compte_utilise == VRAI) ;

/* le problème se situe ici */


compte_utilise = VRAI ;
compte_client = compte_client - derniere_facture ;
compte_utilise = FAUX ;

C. Leghris Systèmes d’exploitation 16


Les processus
 Exclusion mutuelle
 Dans le cas d'une machine multiprocesseurs :
 Avec la variable « compte_utilise » initialisée à « FAUX »,
chaque processus accède, en même temps, à celle-ci et donc
la teste avant que l'autre ne lui ait affecté la valeur « VRAI » ;
 Pour deux processus 1 et 2 par exemple, la valeur « m » du
compte est alors lue, et la valeur finale du compte sera égale
à «m-m1 » ou «m-m2» au lieu d'être égale à «m-m1-m2» ;
 Dans le cas d'une machine monoprocesseur :
 Le processus 1 accède à la variable « compte_utilise » et la
teste, et juste après, il se trouve interrompu par le système
qui donne la main au processus 2 ;

C. Leghris Systèmes d’exploitation 17


Les processus
 Exclusion mutuelle
 Le problème vient d’où ?
 D'une part , du fait qu'un processus peut être interrompu
entre deux instructions ;
 D'autre part, du fait des ressources critiques, lorsqu'elles sont
utilisées par un processus, doivent rester inaccessibles aux
autres processus ;
 De nombreuses solutions ont été proposées pour
résoudre ce problème de l'exclusion mutuelle ;
 Ces solutions se caractérisent par des propriétés
essentielles que toutes devront respecter ;

C. Leghris Systèmes d’exploitation 18


Les processus
 Exclusion mutuelle
 Propriétés essentielles des solutions de l’exclusion
mutuelle :
 A tout instant, un processus au plus peut se trouver en
section critique ;
 Si plusieurs processus sont bloqués en attente de la
ressource critique, l'un d'eux doit pouvoir y rentrer au bout
d'un temps fini ;
 Si un processus est bloqué, ce blocage ne doit pas empêcher
l'entrée d’autres processus dans la section critique de la
ressource ;
 La solution doit être la même pour tous les processus ;

C. Leghris Systèmes d’exploitation 19


Les processus
 Exclusion mutuelle
 Les solutions :
 Attente active
 C’est une solution câblée du problème de l'exclusion mutuelle ;
 Problème :
 Entre le test de la variable booléenne et son affectation par un
processus i, un autre processus j peut accéder à cette variable ;
 L'emploi d'une unique variable booléenne ne convient pas donc ;
 Solution immédiate : Attente Active
 Réaliser ces deux opérations simultanément :
- La nouvelle opération s'appelant TAS (Test And Set) ;
- Cette instruction, agissant sur une variable m ;

C. Leghris Systèmes d’exploitation 20


Les processus
 Exclusion mutuelle
 Les solutions :
 Attente active -TAS
instruction TAS(m) ;
début
bloquer l'accès à la cellule mémoire m ;
lire le contenu de m ;
si m est faux alors
m  vrai ;
compteur_ordinal  compteur_ordinal + 2 ;
sinon
compteur_ordinal  compteur_ordinal + 1 ;
fin si
libérer l'accès à la cellule mémoire m ;
fin
C. Leghris Systèmes d’exploitation 21
Les processus
 Exclusion mutuelle
 Les solutions :
 Attente active -TAS
• Soit p une variable booléenne indiquant que la ressource
critique R est occupée ou non ;
• p est initialisée à faux ;
• L'entrée en section critique est réalisée par :
E : TAS(p)
goto E ;
• Le processus ne pourra sortir de cette boucle que s'il trouve p
est à « faux » pendant l'exécution de l'instruction TAS ;
• La sortie de la section critique est réalisée par p  faux ;

C. Leghris Systèmes d’exploitation 22


Les processus
 Exclusion mutuelle
 Les solutions :
 Attente active
• Retour à l’exemple
/* contexte commun */
compte_utilise = FAUX ;
compte_client = 1000 ;
/* corps du programme du processus i */
derniere_facture = mi ;
E : TAS(compte_utilise) ;
goto E ;
compte_client = compte_client - derniere_facture ;
compte_utilise = FAUX ;
C. Leghris Systèmes d’exploitation 23
Les processus
 Exclusion mutuelle
 Les solutions :
 Sémaphores
 Un sémaphore s est constitué d'une variable « es » et d'une
file d'attente « fs » ;
 Lors de la création du sémaphore, « es » reçoit une valeur
positive (1) et « fs » est vide ;
 On ne peut agir sur un sémaphore qu’au travers deux
primitives indivisibles : Ps et Vs ;
 La primitive Ps correspond à une demande de passage ;

 Celle Vs correspond à une autorisation de passage ;

C. Leghris Systèmes d’exploitation 24


Les processus
 Exclusion mutuelle
 Les solutions :
 Sémaphores

Ps Vs
début début
es  es - 1 es es + 1
si es < 0 alors si es <= 0 alors
Etat r  bloqué Sortir un processus q de la file fs
Mettre le processus r dans la file fs Etat q  actif
fin si fin si
fin fin

C. Leghris Systèmes d’exploitation 25


Les processus
 Exclusion mutuelle
 Les solutions :
 Sémaphores
• Le système devra, pour un sémaphore s, assurer
l'exclusion mutuelle de « es » et « fs », ainsi que
l'indivisibilité des Ps et Vs ;
• L'exclusion mutuelle sera réalisée grâce à un sémaphore
appelé mutex (mutual exclusion), initialisé ainsi :
fmutex  vide et emutex  1
• Et utilisé comme ceci :
Pmutex
instructions formant la section critique
Vmutex

C. Leghris Systèmes d’exploitation 26


Les processus
 Exclusion mutuelle
 Les solutions :
 Sémaphores
• Dès qu'un processus désire utiliser une ressource critique,
il doit obligatoirement réaliser l'opération Pmutex avant.
Deux cas se présentent :
- Le processus décrémente d'une unité la variable emutex, et comme
personne n'utilise la ressource critique, la valeur de emutex qui était 1
passe à 0 ;
- Le processus décrémente d'une unité la variable emutex, et comme un
processus utilise la ressource critique, la valeur de emutex devient ou
reste négative. Le processus demandeur est alors mis dans la file
d'attente fmutex et la procédure Pmutex se termine ;

C. Leghris Systèmes d’exploitation 27


Les processus
 Exclusion mutuelle
 Les solutions :
 Sémaphores
• La libération de la ressource critique se fait
obligatoirement par la procédure Vmutex. Deux cas :
- Le processus incrémente d'une unité la variable emutex . Comme
personne d'autre n'a émis le désir d'utiliser la ressource critique, la
valeur de emutex qui était égale à 0 passe à 1 ;
- Le processus incrémente d'une unité la variable emutex . comme
d'autres processus ont émis le désir d'utiliser la ressource critique,
la valeur de emutex est négative et l'on sort donc de la file d'attente
l'un des processus demandeurs pour le rendre actif ;

C. Leghris Systèmes d’exploitation 28


Les processus
 Exclusion mutuelle
 Les solutions :
 Les sémaphores
• Retour à l’exemple :

Processus et Valeur de File Utilisation de la Valeur de la


derniere_facture = ni ; Instruction compte_utilisé d’attente ressource ressource
- 1 Vide Non 1000 dh
1P 0 Vide Non 1000 dh
P(compte_utilise) ; 2P -1 2 Non 1000 dh
3P -2 2–3 Non 1000 dh
compte_client = compte_client - 1 facture 100 dh -2 2-3 Oui 900 dh
derniere_facture ; 2 en attente -2 2-3 Non 900 dh
3 en attente -2 2-3 Non 900 dh
V(compte_utilise) ; 1V -1 2 Non 900 dh
3 facture 300 dh -1 2 Oui 600 dh
2 en attente -1 2 Non 600 dh
3V 0 Vide Non 600 dh
2 facture 200 dh 0 Vide Oui 400 dh
2V 1 Vide Non 400 dh

C. Leghris 29
Les processus

 Plan :
 Définitions ;
 Exclusion mutuelle ;
 Synchronisation entre processus ;
 Les processus sous Unix ;

C. Leghris Systèmes d’exploitation 30


Les processus
 Synchronisation entre processus
 Il existe des relations qui fixent le déroulement des
processus dans le temps == synchronisation ;
 Le problème de la synchronisation consiste à définir un
mécanisme permettant à un processus actif :
 D'en bloquer un autre ou de se bloquer lui-même en attendant un
signal d'un autre processus ;
 D'activer un autre processus en lui transmettant éventuellement de
l'information ;
 Deux techniques pour résoudre la synchronisation :
 L'action directe permettant à processus d’agir sur un autre ;

 L'action indirecte qui met en jeu plusieurs objets intermédiaires


connus des processus coopérants ;
C. Leghris Systèmes d’exploitation 31
Les processus
 Synchronisation entre processus
 Synchronisation par sémaphores privés
 C’est un mécanisme d'action indirecte ;
 Un sémaphore « s » est un sémaphore privé d'un processus p,
si seul ce processus peut exécuter l'opération P(s) ;
 Les autres processus pouvant agir sur le sémaphore « s » uniquement
par l'opération V(s) ;
 Principe :
 Un signal d'activation sera envoyé par la primitive V, et attendu
par la primitive P ;
 Un processus, dont l'évolution dépend de l'émission d'un
signal par un autre processus, se bloque, au moyen d'une
primitive P, derrière son sémaphore privé initialisé à zéro ;
C. Leghris Systèmes d’exploitation 32
Les processus
 Synchronisation entre processus
 Synchronisation par sémaphores privés
 Le signal de réveil de ce processus bloqué est obtenu en
faisant exécuter, par un autre processus, une opération V sur
le même sémaphore ;
 Exemple :
Soit p un processus dont l'évolution dépend de l'émission d'un
signal envoyé par un processus q. En introduisant le sémaphore
signal initialisé à 0, la solution du problème est comme suit :
Processus p Processus q
Début Début
Ip1 ; Ip2 ; … Ipn ; Iq1 ; Iq2 ; … Iqn ;
P(signal) V(signal)
… ; … ;
Fin Fin

C. Leghris Systèmes d’exploitation 33


Les processus
 Synchronisation entre processus
 Synchronisation par sémaphores privés
 Deux situations sont possibles :
• Le processus p est déjà bloqué sur la primitive P(signal);
o Lorsque le processus q exécute la primitive V(signal), alors le réveil
devient effectif ;
• Le processus p est actif (il exécute par exemple l'instruction
Ipn) ;
o Lorsque le processus q exécute la primitive V(signal), alors le signal
est mémorisé (le sémaphore passe à 1) et lorsque le processus p
exécutera la primitive P(signal), il ne se bloquera pas ;

C. Leghris Systèmes d’exploitation 34


Les processus
 Synchronisation entre processus
 Synchronisation par sémaphores privés
 On peux combiner l'emploi des sémaphores d'exclusion
mutuelle et des sémaphores privés ;
 Dès qu'un processus p ait besoin de connaître la valeur
de certaines variables d'état, il ne peut les consulter
que dans une section critique ;
 Comme il ne peut se bloquer à l'intérieur de celle-ci, le
schéma suivant est utilisé :
P(mutex)
Modification et test des variables d'état ;
Si on peut continuer alors V(sempriv) fin si
V(mutex) P(sempriv)

C. Leghris Systèmes d’exploitation 35


Les processus
 Synchronisation entre processus
 Problème des Philosophes et des Spaghettis
 5 philosophes se réunissent au menu des spaghettis ;
 Les philosophes ne peuvent penser et manger en même temps, et
doivent donc alterner ces activités ;
 Les spaghettis se mangent avec deux fourchettes, et le
restaurateur n'a prévu qu'une seule par personne ;
 Pour résoudre ce problème, ils décident ce qui suit :
• Chacun ne quittera pas sa place pendant le repas ;
• Chacun utilisera les fourchettes de droite et gauche ;
• Chacun doit manger raisonnablement (temps limité) ;
• Chacun ne doit pas s'emparer d'une seule fourchette ;
• Au début du repas, tous les philosophes penseront ;

C. Leghris Systèmes d’exploitation 36


Les processus
 Synchronisation entre processus
 Problème des Philosophes et des Spaghettis
 Il s'agit donc d'élaborer un mécanisme de
synchronisation entre les 5 philosophes (processus) ;
 Les philosophes jouant le même rôle, le mécanisme de
synchronisation sera identique pour tous ;
 L'état d'un philosophe i est caractérisé par une variable :
• etat[i]  REFLEXION, le philosophe i pense :
• etat[i]  ATTENTE, le philosophe i voudrait manger, mais il lui
manque des fourchettes ;
• etat[i]  RIPAILLE, lorsque le philosophe i mange ;

C. Leghris Systèmes d’exploitation 37


Les processus
 Synchronisation entre processus
 Problème des Philosophes et des Spaghettis
 Le passage de l'état REFLEXION à RIPAILLE n'est possible, que si les
philosophes situés sur sa droite et sur sa gauche sont dans un état
différent de RIPAILLE ;
 Si cette condition n'est pas réalisée, le philosophe i passe dans l'état
ATTENTE. Ceci sera fait par un sémaphore privé ;
 La demande de fourchettes s'écrit donc :
P(mutex)
si (etat[gauche(i)]#RIPAILLE) et (etat[droite(i)]#RIPAILLE) alors
etat[i] <- RIPAILLE
V(sempriv[i])
sinon
etat[i] <- ATTENTE
fin si
V(mutex)
P(sempriv[i])
C. Leghris Systèmes d’exploitation 38
Les processus
 Synchronisation entre processus
 Problème des Philosophes et des Spaghettis
 Pour un philosophe i, le passage de l'état RIPAILLE à
REFLEXION entraîne le réveil d’autres philosophes ;
 La restitution de fourchettes s'écrit donc :
P(mutex)
si (etat[gauche(i)]==ATTENTE) et (etat[gauche(gauche(i))]#RIPAILLE) alors
etat[gauche(i)] <- RIPAILLE
V(sempriv[gauche(i)])
fin si
si (etat[droite(i)]=ATTENTE) et (etat[droite(droite(i))]#RIPAILLE) alors
etat[droite(i)] <- RIPAILLE
V(sempriv[droite(i)])
fin si
V(mutex)

C. Leghris Systèmes d’exploitation 39


Les processus
 Synchronisation entre processus
 Problème des Philosophes et des Spaghettis
 En définitive, l'algorithme d'un philosophe i est le
suivant :
iter
sortir si (c'est la Fin_du_Repas)
Penser
Demander_Fourchettes(i)
Manger
Restituer_Fourchettes(i)
fin iter

C. Leghris Systèmes d’exploitation 40


Les processus

 Plan :
 Définitions ;
 Exclusion mutuelle ;
 Synchronisation entre processus ;
 Les processus sous Unix ;

C. Leghris Systèmes d’exploitation 41


Les processus
 Les processus sous Unix
 Un processus sous UNIX correspond à un espace
mémoire composé de trois zones :
 La zone système (u-area) contenant des informations sur
le processus. Elle est manipulée par le système ;
 La zone des données manipulées par le processus ;
 La zone d'instructions où le code du programme, exécuté
par le processus, est stocké ;
 A chaque processus est associé un n° ou pid ;
 Ce n° permet de garder une trace des processus, et
sert également à la synchronisation entre eux ;
C. Leghris Systèmes d’exploitation 42
Les processus
 Les processus sous Unix
 Chaque processus a un père dont le numéro
d'identification est donné par le ppid ;
 Exemple obtenu par la commande ps :
UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 966 959 1 44 0 1.91M 384K pause S ttyp2 0:00.45 csh
25 967 966 0 44 0 1.22M 88K wait I ttyp2 0:00.01 essai

 Il apparait que le processus essai (pid 967, ppid 966)


est le fils du processus csh (pid 966) ;
 Il existe deux fonctions C qui permettent à un
processus de connaître son pid et celui de son père :
int getpid(void) et int getppid(void) ;

C. Leghris Systèmes d’exploitation 43


Les processus
 Les processus sous Unix
 Création de processus
 La fonction system
• Permet à un processus de créer un autre ;
• Inclus dans le fichier entête stdlib.h, le prototype de cette
fonction est : void system(char *commande)
• Le processus appelant étant interrompu jusqu'à la fin de
l'exécution de la commande en argument ;
• Exemple : essai.c
#include <stdio.h>
#include <stdlib.h>
void main(void)
{ system("sleep 60") ;
return ; }

C. Leghris Systèmes d’exploitation 44


Les processus
 Les processus sous Unix
 Création de processus
 La fonction system
• Un appel à la commande ps permet de mieux comprendre :
UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 866 859 1 44 0 1.91M 384K pause S ttyp2 0:00.45 csh
25 867 866 0 44 0 1.22M 88K wait I ttyp2 0:00.01 essai
25 925 867 0 44 0 1.71M 160K wait I ttyp2 0:00.01 sh –c
25 966 925 0 44 0 1.22M 96K - I ttyp2 0:00.01 sleep

• Le processus essai appelle le noyau (par la fonction system) ;


• Cet appel entraine la création d'un processus fils de nom sh–c ;
• Ce processus est à son tour le père du processus sleep (pid 966)
correspondant à la commande sleep 60 (les processus essai et sh -
c seront bloqués jusqu'à la fin du processus sleep) ;

C. Leghris Systèmes d’exploitation 45


Les processus
 Les processus sous Unix
 Création de processus
 Les primitives exec
• UNIX propose d'autres primitives pour créer des processus ;
• Les primitives exec… représentent une famille de primitives
dont l'objectif est la création d'un nouveau processus se
substituant au processus appelant ;
• Exemple :
int execl(char *ref, char *arg0, …, char *argn)
substitue au processus appelant le processus dont le lancement
correspond à l'exécution du programme ‘arg0’, dont la référence
absolue dans l'arborescence des fichiers est donnée par ‘ref’, et
dont les éventuels arguments de travail sont ‘arg1, …, argn’ ;

C. Leghris Systèmes d’exploitation 46


Les processus
 Les processus sous Unix
 Création de processus
 Les primitives exec
• Exemple : programme essai.c
void main(void)
{ execl("/bin/ps","ps", "al" ) ;
printf("et maintenant je m'arrete\n") ;
return ; }

• Au lancement du programme :
UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 866 859 1 44 0 1.91M 392K pause S ttyp2 0:00.45 csh
25 867 866 0 44 0 1.22M 88K - R ttyp2 0:00.01 essai

• Après l'appel à la primitive système execl :


UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 866 859 0 44 0 1.91M 392K pause S ttyp2 0:01.45 csh
25 867 866 0 44 0 1.45M 224K - R ttyp2 0:00.03 ps al

C. Leghris Systèmes d’exploitation 47


Les processus
 Les processus sous Unix
 Création de processus
 La primitive fork
• Elle est utilisée pour la création d'un nouveau processus
obtenu par duplication du processus appelant ;
• Le processus nouvellement créé s'exécute de manière
concurrente au processus qui l'a créé ;
• Le prototype de cette fonction est : int fork(void) ;
• Elle effectue donc une duplication du processus appelant
(copie des données, du code, des priorités, etc.) ;
• Le retour de la fonction fork distinguera le père du fils ;
o Dans le processus fils, elle est nulle, tandis qu'elle est égale au
numéro d'identification du fils dans le processus père ;

C. Leghris Systèmes d’exploitation 48


Les processus
 Les processus sous Unix
 Création de processus
 La primitive fork
• Exemple:
void main(void)
{ printf("Bonjour je vais me dupliquer\n") ;
fork() ;
printf("j'ai réussi\n") ;
return ; }
• Cet exemple provoque deux fois l'affichage du message “j'ai
réussi” ;
• Au lancement du programme, un processus essai a été créé :
UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 866 859 0 44 0 1.91M 400K pause S ttyp2 0:01.45 csh
25 867 866 0 44 0 1.22M 88K - R ttyp2 0:00.03 essai

C. Leghris Systèmes d’exploitation 49


Les processus
 Les processus sous Unix
 Création de processus
 La primitive fork
• Au moment de l'appel à la primitive fork, un deuxième processus
essai est créé ;
• Ce processus est conforme en tous points au premier, à ceci près
qu'il est son fils. Ces deux processus ayant le même code, il est
donc normal que l'on voit s'afficher à l'écran deux fois le
message ;
UID PID PPID CP PRI NI VSZ RSS WCHAN S TTY TIME COMMA
25 866 859 0 44 0 1.91M 400K pause S ttyp2 0:01.45 csh
25 867 866 0 44 0 1.22M 88K - S ttyp2 0:00.03 essai
25 900 867 0 44 0 1.22M 88K - R ttyp2 0:00.03 essai

C. Leghris Systèmes d’exploitation 50


Les processus
 Les processus sous Unix
 Synchronisation de processus
 La primitive wait
• La primitive wait permet de synchroniser, de manière simple,
des processus en suspendant l'exécution du processus en
cours tant que l'un de ces fils ne s'est pas terminé ;
• Le prototype de cette fonction est : int wait(int *code)
• Lorsqu'un processus fils meurt, la fonction wait renvoie son
numéro d'identification ;

C. Leghris Systèmes d’exploitation 51


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Un signal est une interruption logicielle informant un processus
qu'un événement extérieur particulier ou anormal s'est produit
dans son environnement ;
• Exemples :
o Lors d'une division par zéro, le signal « floating point exception » est
émis à l'adresse du processus ne sachant pas calculer ;
o Lorsqu’on interrompe un processus en tapant au clavier « Ctrl-C », le
signal « SIGINT » est envoyé à destination de celui-ci ;
o A la violation de la mémoire, le signal «SIGSEGV» est adressé, etc ;
• Il existe de nombreux signaux, tous sont identifiés ;

C. Leghris Systèmes d’exploitation 52


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• La liste de ces constantes ainsi que toutes les fonctions
permettant de manipuler les signaux sont définies dans le fichier
standard « signal.h » ;
• A chaque signal est associé un événement extérieur, et un
comportement prédéfini du processus recevant le signal ;
• Toutefois, un signal peut être envoyé sans que l'événement
correspondant ne se soit produit ;
o La seule information véhiculée est alors le type du signal ;
o Le comportement standard d'un processus face à un signal peut être
modifié ;

C. Leghris Systèmes d’exploitation 53


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Envoi d'un signal
- L'envoi d'un signal d'un processus à un autre se fait au travers de la
fonction kill dont le prototype est le suivant : int kill(int pid, int sig) ;
- pid : représente le numéro du processus destinataire ;
- sig : le signal émis ;
- Cette fonction renvoie « 0 » si elle s'est correctement déroulée et « -
1 » sinon ;
- Le processus émetteur et le processus destinataire doivent, en
principe, appartenir au même utilisateur ;

C. Leghris Systèmes d’exploitation 54


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Réception d'un signal
- La prise en compte d'un signal par un processus se traduit par un
comportement par défaut désigné symboliquement par la constante
SIG_DFL, et définissant l'action à réaliser lors de la réception du
signal ;
- Ainsi, un processus recevant un signal pourra :
- Se terminer ;
- Ignorer le signal ;
- S'interrompre ;
- Reprendre son exécution ;

C. Leghris Systèmes d’exploitation 55


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Réception d'un signal
- Il est possible pour certains signaux de changer le comportement par
défaut ;
- A la réception d'un signal, un processus pourra ignorer celui-ci
(constante SIG_IGN) ou adopter un autre comportement ;
- Dans ce cas, une fonction définie par l'utilisateur sera associée au
signal ;
- Lors de sa réception, le processus récepteur effectuera un appel à
cette fonction, puis reprendra le cours de son exécution à l'endroit
même où il l'avait quitté ;

C. Leghris Systèmes d’exploitation 56


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Réception d'un signal
- Un signal permet donc de réaliser un appel de fonction alors qu'il n'a
pas été explicitement programmé ;
- La mise en place de ce mécanisme dynamique de déroutement est
obtenue par la fonction signal :
void (*signal(int sig, void (*p_traitement) (int))) (int)
o p_traitement sera initialisé soit avec l'une des constantes
symboliques SIG_DFL et SIG_IGN, soit avec l'adresse de la
fonction associée au traitement du signal sig. Le prototype de
cette fonction est le suivant :
void traitement(int sig)
C. Leghris Systèmes d’exploitation 57
Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Attente d'un signal
- La suspension d'un processus dans l'attente d'un signal est réalisée
par la fonction pause dont le prototype est le suivant : int
pause(void)
- A la délivrance du signal, le processus exécutera le traitement prévu ;
- Exemple :
o Le changement du comportement par défaut d'un processus lors de
la réception d'un signal est comme ci-après ;
o Ici, le processus, au lieu de s'arrêter immédiatement à la réception
du signal SIGINT, s'arrêtera seulement après en avoir capté 5 ;

C. Leghris Systèmes d’exploitation 58


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Attente d'un signal
int c = 0 ;
void capte(int sig) {
printf("Aie !!!, on me reveille\n") ;
c++ ;
if (c > 5) {printf("j'en ai marre, bye bye\n") ; exit(0) ; }
return ; }
void main(void) {
signal(SIGINT,capte) ;
for( ; ;) {
printf("je dors!!!\n") ;
sleep(5) ; }
return ; }

C. Leghris Systèmes d’exploitation 59


Les processus
 Les processus sous Unix
 Synchronisation de processus
 Synchronisation par signaux
• Attente d'un signal
- La fonction capte incrémente la variable c, et lorsque sa valeur sera
supérieure à 5, le programme s'arrêtera ;
- Cette fonction est associée, grâce à la fonction signal, au traitement
par défaut du signal SIGINT, ce qui implique que chaque fois que le
processus recevra ce signal, un appel à la fonction capte sera
immédiatement réalisé ;
- Le programme principal de ce processus est une boucle infinie dans
laquelle le processus affiche “je dors” avant de s'endormir
réellement pendant 5 secondes (fonction sleep) ;

C. Leghris Systèmes d’exploitation 60

Vous aimerez peut-être aussi