Vous êtes sur la page 1sur 43

Communication & synchronisation

des processus

1
Communication inter-processus
Jusqu'à maintenant nous avons considéré les processus
comme des entités isolées n'ayant pour seul objectif que leur
exécution sur le processeur, et n'interagissant pas avec le
système ou avec d'autres processus.
Pourtant, des processus concurrents partagent des données (zones
de la mémoire, des fichiers, des ressources communes …) entre
eux, dans lesquels ils peuvent tous lire et écrire.

 Besoin de communiquer entre processus pour échanger des


données et informations,
 Besoin de synchronisation .

2
Communication inter-processus
Si l’accès concurrent à une ressource commune n’est pas
contrôlé, le résultat de l’exécution du programme pourra
dépendre de l’ordre d’entrelacement de l’exécution des
instructions

 conduit à une série de problèmes complexes d'inter-blocage


ou de corruption de données qui nécessitent l'instauration de
méthodes de synchronisation et d'exclusion mutuelle. C'est ce
que nous allons étudier

3
Communication inter-processus

Définition: Un ensemble de processus est en inter-blocage


si chaque processus attend un événement que seul un autre
processus de l’ensemble peut provoquer.

Exemple: situation possible dans un carrefour à priorité à droite.

4
Communication inter-processus

Exemple 1 de corruption de données:


Utilisation du spoule d'impression:
- Les fichiers à imprimer sont stockées dans un
répertoire de spoule

- Chaque tâche reçoit à son arrivée un numéro d’ordre


d’exécution strictement croissant.

5
Communication inter-processus

Pour administrer ce répertoire, deux variables globales


partagées in et out contiennent respectivement le
prochain numéro de tâche à attribuer, et le prochain
numéro de tâche à imprimer ( toujours in ≥ out )

Supposons que, à un instant donné, on ait in = 7 et out = 4

6
Communication inter-processus

Si, au même moment, deux processus A et B souhaitent lancer l’impression d’un fichier,

ils Doivent chacun exécuter la séquence suivante:


local_in = in;
placer_job (local_in);
in = local_in + 1;
7
Communication inter-processus
Si le premier processus à effectuer cette séquence est
interrompu par l’ordonnanceur entre la 1ère et la 3ème
instruction, les 2 processus utiliseront le même numéro pour
placer leur tâche, et l’un des deux travaux sera perdu.

Le démon d'impression n'en saura jamais rien, et imprimera


uniquement le fichier du dernier processus à exécuter :
placer_job (local_in);

8
Exemple 2-corruption de données
 Deux processus P1 et P2 Procédure:
exécutent cette même procédure
et partagent la même base de * M. X demande une
données
réservation d’avion
 Ils peuvent être interrompus * Base de données dit que
n’importe où fauteuil A est disponible
* Fauteuil A est assigné à X
 Le résultat de l’exécution et marqué occupé
concurrente de P1 et P2 dépend
de l’ordre de leur entrelacement

9
Vue globale d'une exécution possible

P1 interruptions
P2
M. X demande une réservation
d’avion

M. Y demande une
réservation d’avion
Base de données dit à X que fauteuil
30A est disponible
Base de données dit à Y que fauteuil
30A est disponible
Fauteuil 30A est assigné à X et
marqué occupé
Fauteuil 30A est assigné à Y et marqué
occupé

10
Communication inter-processus
Objets et sections critiques

 Problèmes: corruption des données.

 Solution: faire intervenir un seul processus à la fois sur un


objet ou section critique ( exclusion mutuelle)

11
Communication inter-processus
Objet critique Section critique
Objet auquel ne peuvent Suite d'instructions d'un
accéder deux processus programme qui vont
simultanément. manipuler des objets
critiques.

Exemple: fichiers, mémoire


imprimantes, variables... Exemple: lire in;
local_in = in;
Section critique placer_job (local_in);
in = local_in + 1;

12
Communication inter-processus
Structure d'un programme
 Chaque processus doit donc demander une permission avant d’entrer dans une
section critique (SC)
 La section de code qui effectue cette requête est la section d’entrée
 La section critique est normalement suivie d’une section de sortie
 Le code qui reste est la section restante
section d’entrée

section critique
section de sortie
section restante

Avec l'hypothèse qu'un programme ne contint qu'une seule section critique.

13
Application

14
Communication inter-processus
Race conditions (conditions de course)
 Les situations dans lesquelles des processus peuvent être en ''course'' pour
accéder à certaines ressources et dont le résultat dépend de l'ordre d'accès
sont appelées conditions de course ( race conditions) .

=> Non déterminisme: le résultat est aléatoire avec les mêmes données.

 Solution: une section critique SC ne doit être exécutée que par un seul
processus à la fois ( on dira que le processus est dans sa SC)

15
Critères nécessaires pour solutions valides
 Deux processus ne peuvent pas être en même temps en section critique
relative à une ressource commune.
 Aucune hypothèse ne doit être faite sur les vitesses relatives des
processus et sur le nombre de processeurs.
 Non interférence: Si un processus s’arrête dans sa section restante ( en
dehors de sa section critique ) , ceci ne devrait pas affecter les autres
processus = ne doit pas les bloquer.
 Progrès: absence d'inter-blocage; c-à-d: si un processus demande
d’entrer dans une section critique à un moment où aucun autre processus
n'en fait la requête, il devrait être en mesure d’y entrer.

16
Types de solutions

 Solutions logiciel
des algorithmes dont la validité ne s’appuie pas sur l’existence
d’instructions spéciales.
 Solutions fournies par le matériel
s’appuient sur l’existence de certaines instructions spéciales (du
processeur).
 Solutions fournies pas le SE
procure certains appels systèmes au programmeur.

17
Remarques

Toutes les solutions se basent sur l’atomicité de l’accès à la


mémoire centrale: une adresse de mémoire ne peut être
affectée que par une instruction à la fois, donc par un processus
à la fois.

Plus en général, toutes les solutions se basent sur l ’existence


d’instructions atomiques, qui fonctionnent comme des SC de
base

Atomicité = indivisibilité

18
Solutions logicielles
1- l'alternance stricte:
On utilise une variable tour partagée qui va contenir le numéro du
processus à entrer en section critique.
Algorithme pour 2 processus:
entrer_SC(int NumProcess) sortir_SC()
{ {
While ( tour != NumProcess) /* attente active */ tour=(autreProcess);
}
}

19
Solutions logicielles
Alternance stricte

Avantages: simple et facile à utiliser.

Inconvénients: Risque de famine, si le tour est donné à un


processus non intéressé par la SC.

20
Solutions logicielles
4- Algorithme de Peterson (1981):
On va introduire une nouvelle variable par processus pour
savoir s'il est intéressé ou non par la SC.

21
Algorithme de Peterson
#define N 2 /* nombre de processus */

/* variables partagées par tous les process */


int tour; /* à qui le tour */
int interesse[N]; /* initialisé à faux */

void entrer_region(int processus) /* process appelant vaut 0 ou 1 */


{
int autre; /* numéro de l'autre processus */
autre = 1-processus;
interesse[processus] = vrai; /* indiquer son intérêt */
tour = processus; /* positionner le drapeau d'accès */
while(tour == processus && interesse[autre] == vrai); /* attente active*/
}

void quitter_region(int processus) /* numéro du processus appelant ici process vaut 0


ou 1 */
{ interesse[processus] = faux;
/* indiquer la sortie de la section critique */
} 22 22
Algorithme de Peterson
Process P0: Process P1:
autre=1 autre=0;
interesse [0] = vrai; interesse[1] = vrai;
// 0 veut entrer // 1 veut entrer
tour = 0; tour = 1;
while
(intesse[1]==vrai&&tour=0) while
{}; (intersse[0]==vrai&&tour=1)
SC {};
interesse[0] = faux; SC
// 0 quitte section critique interesse[1] = faux;
SR // 1 quitte section critique
SR
Algorithme de Peterson vue globale

23 23
Algorithme de Peterson

L'idée principale de l'algorithme est d'utiliser deux variables


différentes :

l'une indiquant que l'on s'apprête à utiliser une ressource


commune (interesse[ ]), et l'autre (tour) qui, comme dans le
cas de l'alternance, indique le processus qui utilisera la
ressource au prochain tour.

24
Algorithme de Peterson
Lorsqu'un processus veut entrer en section critique, il notifie les autres de
ses intentions en positionnant correctement son entrée dans le tableau
interesse[ ], puis il s'approprie le prochain tour.

Si les 2 processus appellent enter_region simultanément, tous deux vont


stocker leur numéro de processus dans tour

C’est l’opération de stockage la plus tardive qui est prise en compte.


Supposons que le processus soit stocké en dernier est P1 : tour=1.
Lorsque les 2 processus arrivent à l’instruction while,
- le processus 0 ne l’exécute pas et entre en SC.
- Le processus 1 boucle et n’entre pas en SC tant que le processus 0
n’a pas quitté la sienne

25 25
Solutions logicielles
Lacunes des solutions logiciel
 Difficiles a programmer!
 Les processus qui requièrent l’entrée dans leur SC sont
occupés à attendre (busy waiting); consommant ainsi du
temps processeur

 Pour de longues sections critiques, il serait préférable de


bloquer les processus qui doivent attendre...( les
endormir)

26
Solution matérielles
En étudiant de près les problèmes liés à l'exclusion mutuelle et
la corruption de données qui peut en découler, on constate
que le point critique se trouve entre la lecture d'une variable
et son écriture.

Si un changement de contexte intervient entre ces deux actions,

et un autre processus écrit dans la variable après que la


première l'ait lue,

le premier se trouve dans un état incohérent, et peut, ensuite


provoquer des actions néfastes (comme l'exemple du spoule
d'impression).

27
Solution matérielles

Cette analyse a conduit, sur certaines architectures, à


introduire une commande atomique au niveau du
langage d'assembleur, permettant à la fois de lire
et d'écrire une variable en une instruction

28
Solution matérielles
L'instruction: TSL RX, LOCK
Test and Set Lock, ( tester et définir le verrou ) qui fonctionne
ainsi:
Elle charge le contenu du mot mémoire LOCK dans le registre
RX, et en même temps, elle met la valeur LOCK à 1.
Cette instruction est garantie comme étant atomique, c'est-à-dire
que l'arrivée d'une interruption ne sera acquittée par le processeur
que lorsque l'opération du TSL sera terminée

Le processeur dispose de petites zones de mémoire très rapides,


appelées registres

29 29
Avantage de l’instruction TSL
elle occupe le bus pendant toute son exécution. De ce simple
fait, elle empêche d'éventuels autres processeurs d'accéder en
même temps au mot mémoire LOCK.

Lorsque LOCK est à 0, n’importe quel processus peut la


positionner à 1 via TSL et entrer en SC, à la fin de la SC, le
processus repositionne LOCK à 0 à l’aide d’une instruction
move.
Du fait de l’atomicité, les fonctions entrer_region() et
quitter_region() peuvent êtres écrites en assembleur de la
façon suivante :

30 30
Solution matérielles
entrer_region:
Label:
TSL Reg, Verrou | copier verrou dans Reg, et mettre lock à 1
CMP Reg, #0 | verrou était-elle à 0 ?
JNE Label | si différent boucler ( aller au début et refaire l
|le test
RET | Retourne à l’appelant, entre en section
|Critique

quitter_region:
MOVE Verrou, #0 | écrire 0 dans lock
RET
31 31
Problème:
Attente active: Consommation des ressources du processeur. Un
processus qui est en attente, effectue une boucle while, gaspillant
ainsi du temps processeur inutilement.
Exemple: supposons qu'on a 2 processus H avec une haute priorité
et B avec une basse priorité.
Si H est entrain de réaliser une opération d' E/S et B entre en SC. H
termine son E/S élu (prioritaire) va être exécuté avant que B
ne sorte de sa SC donc H va boucler indéfiniment.

32
Solutions avec attente passive (SE)
Solution:
Endormir un processus en attente et le réveiller dès que la
ressource est libre, pour cela , il y a 2 appels système:
 Sleep() pour endormir le processus appelant
 Wakeup(...) pour réveiller le processus passé en
argument

33
Solutions avec attente passive
Exemple: problème producteur/consommateur

Tampon de taille fixe


Producteur Consommateur

Conditions de dépôt et de retrait


⧫ Dépôt : buffer non plein

⧫ Retrait : buffer non vide

Protéger les données partagées

34
Solutions avec attente passive

Problèmes:

 Tampon plein et producteur veut rajouter un élément


 Tampon vide et consommateur veut retirer un élément
 Exclusion mutuelle, un seul processus doit manipuler le tampon à la fois

35
Solutions avec attente passive
Algorithme
Soit N la taille du tampon.
On va jouer sur le nombre d'éléments dans le tampon qu'on va
stocker dans une variable compteur
#define N 100 /* nbre d’emplacement ds tampon */

int compteur = 0 ; /* nbre d’objets ds tampon */

void producteur () { void consommateur () {


Int element ; while (vrai) {
while (VRAI) { if (compteur == 0) sleep() ;
element=produire_element() ; retirer_element(…);
if (compteur == N) sleep () ; compteur = compteur – 1 ;
mettre_element(element) ; if (compteur == N-1)
compteur = compteur + 1 ; wakeup (producteur) ;
if (compteur == 1) wakeup(consommateur) }
} }
} 36
Solutions avec attente passive
Analyse de cette solution :
1. L’accès à la variable compteur n’est pas protégé (objet
critique), ce qui peut entraîner des incohérences dans les
valeurs prises par cette variable

2. Réveils perdus : c’est le principal défaut de ce mécanisme.


Un signal wakeup envoyé à un processus qui ne dort pas
(encore) est perdu.
Exple :compteur=N /* fin quantum du producteur

37
Sémaphores
Pour contrôler les accès à un objet partagé E. W. Dijkstra
proposa en 1965 un nouveau type de variables appelées:
sémaphores. Ils sont maintenant largement utilisés dans les
systèmes d'exploitation modernes.
Définition:
 Un sémaphore est un compteur entier qui désigne le nombre
d'accès disponible à une certaine ressource.
 Chaque sémaphore à un nom et une valeur initiale.
 Les sémaphores sont manipulés par des opérations:
 P() (désigné aussi par down() ou wait ) décrémente le
sémaphore.
 V() ( désigné par up() ou signal ) incrémente la sémaphore.

38
Sémaphores
La commande V(), incrémente le sémaphore.

La commande P() décrémente la valeur du sémaphore si elle est strictement


supérieure à zéro, puis rend la main à l'appelant

Si la valeur du sémaphore vaut zéro, le processus bascule en mode bloqué


jusqu'à ce que la valeur du sémaphore redevienne positive et que le
processus soit réveillé par le système.
Le test du sémaphore, le changement de sa valeur, et la mise en attente
éventuelle sont effectués en une seule opération atomique indivisible.
Lors de son réveil, le processus décrémente la valeur du sémaphore et
continue son exécution.

39
Sémaphores
Solution du problème producteur /consommateur

On aura besoin de 3 sémaphores :


1- mutex: pour assurer l'exclusion mutuelle initialisé à 1
2- occupe: compte le nombre d'emplacements occupés
initialisé 0, il sert à bloquer/débloquer le consommateur
3- libre: compte le nombre d'emplacements libres initialisé à N,
il sert à bloquer/débloquer le producteur.

40
Sémaphores
#define N 100 /* nombre de places dans le tampon */

Semaphore mutex = 1 ; /* contrôle d'accès au tampon */

semaphore libre = N ; /* nb de places libres */

Semaphore occupe = 0; /* nb de places occupées */

void producteur (void) {

Int element ;

while (TRUE) {element= produire_element () ; /* produire l'élément suivant */

P (libre) ; /* déc. nb places libres */

P (mutex) ; /* entrée en section critique */

mettre_element (element) ; /* mettre l'élément dans le tampon */

V (mutex) ; /* sortie de section critique */

V (occupe) ; /* inc. nb place occupées et wakeup consommateur*/

}
41
}
Sémaphores
void consommateur (void)
{
int element ;
while (TRUE) {
P (occupe) ; /* déc. nb emplacements occupés */
P (mutex) ; /* entrée section critique */
prelever_element () ; /* retire un élement du tampon */
V (mutex) ; /* sortie de la section critique */
V (libre) ; /* inc. nb emplacements libres */
}
}

42
Sémaphores
Remarque
semaphore S;
 P(S) décrémente le sémaphore S si S>0 sinon blocage
du processus appelant.
 V(S) incrémente le sémaphore S si aucun processus
n'est bloqué par P(S), sinon l'un d'entre eux sera choisi
pour être élu

43

Vous aimerez peut-être aussi