Académique Documents
Professionnel Documents
Culture Documents
Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites Avec
Arbitrage
1 Introduction
Expos du problme
Les entits (processus ou threads) en cours dexcution
sont gnralement :
Indpendantes et Asynchrones
Leur fonctionnement ne dpend pas a priori du travail ralis par
les autres entits
Elles peuvent a priori progresser leur rythme sans se soucier les
unes des autres : elles pourraient sexcuter en parallle, mme si
sur un seul CPU, on parlera de pseudo paralllisme
1 Introduction
La notion de Concurrence
Dfinition :
Rivalit dintrt entre entits provoquant une comptition
Ressources physiques [ partager car en nombre insuffisant]
Processeur, disque, imprimante,
1 Introduction
1 Introduction
Illustrations (1/3)
Exemple 1 :
Pour tout i, Pi ne doit pas imprimer tant que une
autre impression est en cours !
Processus P
Processus Q
imprimer(ligne l1)
imprimer(ligne k1)
imprimer(ligne l2)
imprimer(ligne k2)
1 Introduction
Illustrations (2/3)
Exemple 2 :
Une instruction assembleur est indivisible, mais
pas une suite dinstructions
variable commune : n (compte bancaire)
P(Virement nP)
nP)
n:=n+nP
n:=n+nP
Q(Virement nQ)
nQ)
n:=n+nQ
n:=n+nQ
Actions_P :
1. load Reg_P, n
2. add Reg_P, nP
3. store Reg_P, n
Actions_Q :
1. load Reg_Q, n
2. add Reg_Q, nQ
3. store Reg_Q, n
1 Introduction
Illustrations (3/3)
Exemple 2 (suite)
Actions_Q :
1. load Reg_Q, n
2. add Reg_Q, nQ
3. store Reg_Q, n
1, 2, 3, 1, 2
2, 3
3
n=n+nP
+nQ
n=n+nP+
1, 2
2, 3
3, 1, 2, 3
OK !
1, 1, 2, 2, 3, 3
1, 2, 1, 2
2, 3, 3
n=n+nQ
n=n+nQ
1, 1, 2
2, 2, 3, 3
PBM : nP perdu !
1, 2, 1, 3, 2, 3
3
1, 1, 2, 3, 2, 3
3
1, 1, 2, 2, 3, 3
1, 2
2, 1, 2, 3, 3
n=n+nP
n=n+nP
1, 1, 2, 2, 3
3, 3
PBM : nQ perdu !
1, 2
2, 1, 3, 2, 3
1, 1, 2, 3
3, 2, 3 Il faut que : 3 pr
prcde (<) 1
1 ou 3
3 < 1
1 Introduction
Solution au Problme
Imposer que les sections critiques soient excutes
de manire non entrelace
pour garantir une utilisation correcte des ressources
Limprimante dans lexemple 1
La variable n dans lexemple 2
1 Introduction
1 Introduction
Demande de la ressource
<section de code critique>
Lib
Libration de la ressource
1 Introduction
(1/2)
Exclusion mutuelle
A tout instant, un processus au plus excute des instructions de sa
section critique
2.
3.
1. Introduction
(2/2)
5.
Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites Avec
Arbitrage
P1
P2
P2
Rpter
Tant que (Tour = 2) Faire
sleep(d
lai);
sleep(d
Fintantque
<section critique>
Tour :=2
Jusqu
Jusqu faux
Rpter
Tant que (Tour = 1) Faire
sleep(d
lai);
sleep(d
Fintantque
<section critique>
Tour :=1
Jusqu
Jusqu faux
Absence de famine : Ok
Code identique : NON
P1
P1 en SC =>
Drapeau2=faux OU Tour =1
P1 en SC =>
Drapeau1 = vrai
ET
ET
P2 en SC =>
Drapeau1=faux OU Tour =2
P2 en SC =>
Drapeau2 = vrai
10
Drapeau2=vrai
ET Tour = 2
ET
Drapeau1= vrai
ET Tour = 1
Drapeau2 = faux
Drapeau2=vrai ET Tour = 2
Donc
Drapeau2 = faux ET
Drapeau2 = vrai
=> Impossible !
11
ET
P2 attend : en effet
Analyse:
Absence de blocage : OK, lordonnanceur du CPU finit par donner
la main un processus voulant rentrer dans sa SC
Condition de progression : OK
Absence de famine : OK si lordonnanceur lassure (normalement
oui !)
Code identique : OK
12
1.
2.
1.
2.
prev = var
var = 1
P1
P2
prev = TAS(verrou
);
TAS(verrou);
Tant que (prev = 1)
Faire
/* sleep(d
lai); */
sleep(d
prev = TAS(verrou
);
TAS(verrou);
Fintantque
<section critique>
verrou = 0;
prev = TAS(verrou
);
TAS(verrou);
Tant que (prev = 1)
Faire
/* sleep(d
lai); */
sleep(d
prev = TAS(verrou
);
TAS(verrou);
Fintantque
<section critique>
verrou = 0;
13
Exclusion mutuelle : Ok
Absence de blocage : Ok
Condition de progression : Ok
Absence de famine :
Ok si lordonnanceur lassure (cad si nactive pas Pi
ternellement),
sinon, cest NON
si Pi quitte sa SC, garde le CPU et se prsente nouveau
lentre de la SC : verrou toujours 0, donc Pi entre
nouveau (remarque applicable aussi pour sol.
Masquage )
Code identique : Ok
14
Bilan
Solutions avec attente active gourmandes en
temps CPU
Solutions ad-hoc:
programmation plus technique, source derreurs si
on oublie de librer la SC
15
Introduction
Solutions avec attente active, dites Sans Arbitrage
Solutions avec blocage (attente passive), dites
Avec Arbitrage
Gnralits
Les solutions avec attente active sont gourmandes en
temps CPU
Lorsque lattente est longue
Lorsque plusieurs (nombreux) concurrents attendent
16
Principe de fonctionnement
Rpter
17
Description
Smaphore = type abstrait
structure de donnes (compteur + file dattente dentits)
interface (oprations, dont initialisation, sur la structure de donnes)
Smaphores (2)
structure de donnes :
Val : entier sign, indique un nombre de permissions
File : file de (contexte ou descripteur) entits
oprations :
init(s:smaphore, val_init : entier)
s.Val = val_init
18
Smaphores: opration P
Op
Opration P(s:semaphore
P(s:semaphore))
Si (s.Val
(s.Val <=0)
Alors //ranger le descripteur du processus dans s.File
ajouter (s.File
(s.File,, descripteur processus courant);
//mettre le processus dans l
tat bloqu
ltat
bloqu
descripteur courant . Etat = BLOQU
BLOQU
//choisir un nouveau processus rendre actif
faire appel lordonnanceur pour qu
quil choisisse
Sinon s.Val := s.Val 1;
FinSi
Smaphores: opration V
Op
Opration V(s:semaphore
V(s:semaphore))
Si (s.File
(s.File non vide)
Alors //retirer
//retirer de s.File le descripteur d
dun processus
P= retirer (s.File
(s.File))
// mettre ce processus dans l
tat prt
ltat
P. etat = PR
PRT
Sinon s.Val := s.Val + 1;
FinSi
19
Pi pour tout i :
Rpter
<hors section critique
critique>
P(Mutex
P(Mutex))
<section critique>
V(Mutex
V(Mutex))
<hors section critique
critique>
Jusqu
Jusqu
20
Moniteurs
[Hoare, 1974 Brinch Hansen, 1975]
Motivation : cette poque, mergence du concept de type
abstrait: structure de donne cache manipule par des
oprations de spcification connue (prcurseur dobjet!)
Do lide vidente : intgrer les protocoles dentre et de
sortie de SC au dbut et la fin des oprations spcifies comme
devant sexcuter en exclusion mutuelle
Cest le compilateur qui rajoute les instructions du protocole
dentre et de sortie, souvent base de smaphores.
Schma moniteur
monitor <monitor-name> {
<shared variables + conditions declarations>
procedure P1 () {
...
}
procedure P2 () {
...
}
procedure Pn () {
...
}
{ initialization code }
}
21
Moniteurs (2)
Exemple de moniteur : gestion de compte bancaire
/* ressource acc
accs exclusif */
/* en exclusion mutuelle avec Virement */
proc
procdure Virement(montant
Virement(montant : entier) /* en exc. mut. avec Etat & Virement */
dbut
solde := solde + montant;
montant;
fin
dbut
solde := 0 ;
fin
/* Initialisation du moniteur */
Moniteurs (3)
Exemple (suite)
Activits concurrentes :
Activit
Activit P :
Un_compte.Virement(
Un_compte.Virement(nP);
nP);
Activit
Activit Q :
Un_compte.Virement(
Un_compte.Virement(nQ);
nQ);
Un_compte.
Un_compte. Etat();
Activit
Activit R :
Un_compte.Virement(
Un_compte.Virement(nR);
nR);
Un_compte.
Un_compte. Etat();
22
Oprations wait et
notify/notifyAll
pour grer une
unique variable de condition
associe au moniteur
class ExMut {
int cpt; // shared data of the instance
public synchronized void dec() {
cpt--; // cest une section critique
}
public synchronized void inc() {
cpt++; // cest une autre SC
}
}
class SynchroCond {
int cpt; // shared data
public synchronized void get() {
if (cpt <= 0) wait();
cpt--; // cest bien sr une SC !
}
public synchronized void put() {
cpt++;
notify();
}
}
23
notify() :
if !empty(blocked) {
thread = get(blocked)
wakeup(thread)
}
Entrelacer des P ?
Test et modif. de Val:
dans une SC ? OUI
1 et si test False, 2
Entrelacer des P et V ?
Test de val et
manipulation de la
file: dans une SC ? OUI
1
24
4 Conclusions
25
4 Conclusions
4 Conclusions
26