Vous êtes sur la page 1sur 19

SYNCHRONISATION

INTERPROCESSUS
SAIDOUNI Djamel Eddine
BOUZENADA Mourad

Université Constantine 2 - Abdelhamid Mehri


Faculté des Nouvelles Technologies de l’Information et de la Communication
Département d’Informatique Fondamentale et ses Applications

Laboratoire de Modélisation et d’Implémentation des Systèmes Complexes

Djamel.saidouni@univ-constantine2.dz
Mourad.bouzenada@univ-constantine2.dz
PLAN
 Problème de la section critique.
 Solutions algorithmiques
 Solutions pour deux processus
 Solutions pour plusieurs processus
 Conception d’un algorithme pour le problème de la SC
 Outils pour la synchronisation des processus.
 Solutions matérielles
 Sémaphores
 Moniteurs
 Paradigmes universels.
2018-09-30

2
Saïdouni Djamel Eddine & Bouzenada Mourad
PLAN DE LA SÉANCE

 Problème de la section critique.


 Exemple Illustratif
 Exclusion mutuelle
 Critères nécessaires pour une solution valide
 Classification des propriétés d’une solution
 Validation d’une solution
 Types de solutions
 Solutions algorithmiques
 Solutions pour deux processus

2018-09-30

3
Saïdouni Djamel Eddine & Bouzenada Mourad
EXEMPLE ILLUSTRATIF
Programme
var x: integer init 0 // variable partagée

TA 1 TA 2
begin begin
. .
. .

x:=x+1 x:=x+1
. .
. .
end end

Quel est la valeur attendue de x ?


2018-09-30

4
Saïdouni Djamel Eddine & Bouzenada Mourad
EXEMPLE ILLUSTRATIF
Programme
var x: integer init 0 // variable partagée

TA 1 TA 2
begin begin
. .
. .
(1) LDA x Acc=0 (1’) LDA x Acc=0
(2) INC Acc=1 (2’) INC Acc=1
(3) STA x x=1 (3’) STA x x=1
. .
. .
end end

Dans ce cas la valeur de x est 1 (Valeur erronée)


2018-09-30

5
Saïdouni Djamel Eddine & Bouzenada Mourad
EXEMPLE ILLUSTRATIF
Programme
var x: integer init 0 // variable partagée

TA 1 TA 2
begin begin
. . SECTION
. . CRITIQUE

x:=x+1 x:=x+1
. .
. .
end end

2018-09-30

6
Saïdouni Djamel Eddine & Bouzenada Mourad
Exclusion Mutuelle
Imposer que les sections critiques soient exécutées de manière
entrelacée dans le temps (une après une).
On dit aussi qu’une section critique doit être indivisible ou atomique.

Section (de code) Critique : Code devant pouvoir faire l’hypothèse


qu’il utilise la ressource de manière exclusive.

Si aucune précaution particulière n’est prise, rien n’empêche


plusieurs processus à la fois d’utiliser la ressource.
⇒ Empêcher les processus qui sont en compétition (pour une ressource
donnée) d’entrer simultanément dans leur section [de code] critique.
⇒ Les sections critiques s’exécutent donc en exclusion mutuelle.

2018-09-30

7
Saïdouni Djamel Eddine & Bouzenada Mourad
Exclusion Mutuelle
• La structure général de chaque processus en concurrence

Section de début (SD)


section d’entrée
section critique (SC) Solution
section de sortie
section restante (SR)
• La section de début (SD), la section critique (SC) et la section
restante (SR) sont données (code de l’application).

• Doit définir la section d’entrée (section de code qui effectue une


demande d’entrer dans la SC) et la section de sortie (code qui
suit normalement la SC).
2018-09-30

8
Saïdouni Djamel Eddine & Bouzenada Mourad
Critères nécessaires pour une
solution valide
Hypothèse: Le temps de résidence d’un processus dans sa SC est fini.
1. Exclusion mutuelle – Si le processus Pi exécute sa SC alors aucun
autre processus ne peut exécuter sa SC (à tout instant t, Not(Pi en Sci
and Pj en Scj)). (Sûreté)
2. Progrès - Si aucun processus n’exécute sa SC et si certains processus
désirent entrer dans les leurs, alors seulement les processus qui ne se
trouvent pas dans leurs SRs peuvent décider qui rentrera
prochainement à sa SC. Cette sélection ne peut pas être reportée
indéfiniment
 Absence d’interblocage (Vivacité globale du système).
 Non interférence: Si un processus s’arrête dans sa SR, les
autres processus devront pouvoir accéder à leurs SCs
3. Attente limitée - Il doit exister une limite au nombre de fois que l’on
permet à d’autres processus à entrer dans leurs SCs après qu’un
processus a effectué une requête pour entrer dans sa SC et avant que la
requête ne soit accordée.
– Absence de famine (Vivacité locale ou partielle de chaque
processus).
2018-09-30

9
Saïdouni Djamel Eddine & Bouzenada Mourad
CLASSIFICATION DES PROPRIÉTÉS
D’UNE SOLUTION

 Propriété de sûreté: Quelque chose de mauvais


n’arrivera jamais.
 Problème de la section critique: Propriété de l’exclusion
mutuelle
 Propriété de vivacité: Quelque chose de bon
arrivera sûrement
 Problème de la section critique:
 Vivacité globale du système: Si des processus sont
demandeurs d’accès à leurs SCs et que la section critique
est libre, alors un parmi ces demandeurs finira par
accéder à sa SC.
 Vivacité locale ou partiellle: Tout processus demandeur
d’accès à sa SC finira par y accéder au bout d’un temps
fini.

10
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
VALIDATION D’UNE SOLUTION

1. Vérifier la propriété de sûreté, dans notre cas la propriété


d’exclusion mutuelle. Si la solution ne vérifie pas la sûreté,
ce n’est pas la peine de vérifier les deux autres propriétés.

2. Vérifier la propriété de progrès (vivacité globale). Si le


système n’est pas vivant alors la famine peut toucher tous
les processus. De ce fait on ne vérifie pas la propriété de
l’attente limitée.

3. Vérifier la propriété de l’attente limitée (vivacité partielle).

11
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Types de solutions

- Avec prise en charge matérielle.

- Des solutions logicielles.

-Solutions avec attente active, dites Sans Arbitrage

- Solutions avec blocage (attente passive), dites Avec Arbitrage

12
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 1
• Ayons une variable partagée turn qui indique à qui le tour.
• Initialisée à 0 ou 1, pas de différence.
• Tâche Ti peut entrer dans sa SC ssi turn = i
• À la sortie de la SC, turn est affectée par l’autre valeur, afin de
permettre à l’autre tâche d’accéder à sa SC.
• Ti peut être occupée à attendre si Tj est dans SC.
Tâche T0: Tâche T1:
while(true) while(true)
{ {
while(turn!=0){ } while(turn!=1){ }
Section critique Section critique
turn:=1; turn:=0;
Section restante Section restante
} }

13
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 1
Discussion:
• Assure-t-il l’exclusion mutuelle?
– Oui, à tout moment turn n’a
qu’une valeur, et si la tâche Ti est Tâche Ti:
dans sa SC alors turn=i. while(true)
{
while(turn!=i){ }
• Assure-t-il le progrès?
Section critique
– Non, car l’alternance entre tâches turn=j;
est stricte. Section restante
– Si une tâche se termine suite à }
l’exécution de sa section restante
alors que l’autre tâche a besoin de
faire plusieurs cycles, elle se
retrouvera bloquée dans sa SE.

14
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 2
– On introduit des variables partagées flag[0] et flag[1] pour
indiquer si tâche T0 et tâche T1 veulent respectivement entrer dans
leurs SCs respectives.
– Tâche Ti met à vrai flag[i] avant d’essayer d’entrer dans sa SC et à
faux flag[i] en sortant de sa SC.
– Ti n’entre pas dans sa SC tant que flag[j] est vrai.
– Si une tâche veut entrer dans sa SC à plusieurs reprises, elle n’aura
aucun problème, car le drapeau de l’autre tâche sera toujours faux.
Tâche T0: Après Tâche T1:
Après
while(true) vous! while(true) vous!
{ {
flag[0] = true; flag[1] = true;
while(flag[1]){ } while(flag[0]){ }
Section critique Section critique
flag[0] = false; flag[1] = false;
Section restante Section restante
} }

15
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 2
Discussion:
• Assure-t-il l’exclusion mutuelle?
Tâche Ti:
– Oui, une tâche dans sa SC a vrai
while(true)
dans son flag, mais n’entre pas si le
{
flag de l’autre est vrai.
flag[i] = true;
while(flag[j]){ }
• Assure-t-il le progrès? Section critique
– Qu’arrive-t-il suite à la séquence flag[i] = false;
d’instructions: Section restante
• T0: flag[0] = vrai; }
• T1: flag[1] = vrai; ?
– Pas de progrès: l’interblocage.

16
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 3
 Utilisons flag[i] pour indiquer le désire d’entrer à la SC
 Mais aussi turn afin de permettre à l’autre tâche d’entrer à sa SC
Tâche T0: Task T1:
while(vrai) while(vrai)
{ {
flag[0] = vrai; flag[1] = vrai;
// T0 veut entrer // T1 veut entrer
turn = 1; turn = 0;
// T0 donne une chance à T1 // T1 donne une chance à T0
while while
(flag[1]==vrai&&turn==1){} (flag[0]==vrai&&turn==0){}
Section critique Section critique
flag[0] = faux; flag[1] = faux;
// T0 sort // T1 sort
Section restant Section restante
} }

17
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 3

• Assure-t-il l’exclusion mutuelle? On fait une preuve par l’absurde


– Supposons que les deux tâches réussissent à accéder leurs SC
en même temps.
– Cas 1: Ti trouve la condition flag[1-i]==vrai&turn==1-i
fausse avant que T(1-i) ne positionne son flag à vrai.
Dans ce cas lorsque T(1-i) exécute la boucle while il a
déjà positionné turn à i et Ti en Sci (donc
flag[i]==vrai). Ce qui est absurde.
– Cas 2: Les deux tâches ont positionné leur flag à vrai
avant qu’elles arrivent à la boucle while. Dans ce cas
turn!=1 et turn!=0, ce qui est absurde.

18
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad
Solutions pour deux processus
Algorithme 3
Assure-t-il le progrès? Soit l’hypothèse que la SC est libre. Deux cas se présentent.
Cas 1: Seule la tâche Ti demande l’accès à sa SC. Dans ce cas turn = 1-i et
Flag[1-i] = faux. Ti réussira donc à franchir la boucle while et entre dans sa
SC.
Cas 2: Les deux tâches sont demandeurs d’accès à la SC. Donc flag[i] =
flag[1-i]=vrai. Quelque soit l’ordre dans lequel les instructions turn = 1-i et
turn = i sont exécutées, la variable turn prendra la valeur 0 ou 1. Donc
l’une des deux conditions se trouvera fausse et l’une des tâches réussira à
accéder à sa SC.
Assure-t-il l’attente limitée?
Nous montrons que si Ti est demandeur (bloquée au niveau de la boucle
While) alors que T(1-i) est dans sa SC. On montre que même si T(1-i)
détient le processeur et qu’elle quitte sa SC et redemande une autre fois
l’accès à sa SC, elle ne réussira pas à y accéder. Dans ce cas elle positionne
son flag à vrai et turn à i alors que flag[i] est vrai. Dans ce cas T(1-i) restera
bloqué dans l’instruction while, et dès que Ti se voit affecté le processeur,
sa condition d’attente étant faux, accèdera donc à sa SC.

19
2018-09-30
Saïdouni Djamel Eddine & Bouzenada Mourad

Vous aimerez peut-être aussi