exclusion mutuelle -...

Exclusion Mutuelle

Arnaud LabourelCourriel : [email protected]

Universite de Provence

9 fevrier 2011

Arnaud Labourel (Universite de Provence) Exclusion Mutuelle 9 fevrier 2011 1 / 53

Exclusion Mutuelle

Contexte “Epistemologique”

Comment etre sur qu’un programme est vraimentcorrect ?


Exclusion Mutuelle

Sections Critique et Exclusion Mutuelle

Etant donne du code, on peut y definir des portionsparticulierement importantes que l’on denote par sectioncritique (SC).Exemple: manipulation d’une variable partagee.

/* Du code */

...

/* Section Critique */

... // variable partagee

/* Fin de la Section Critique */

/* Encore du Code */

...


Exclusion Mutuelle

Une solution

Exclusion Mutuelle : Il y a au plus une entite ensection critique.

⇒ Permet de reguler l’acces aux donnees.


Exclusion Mutuelle

Mais ...

Cette specification est incomplete pour pouvoir etreutilisee rigoureusement...

La solution “il est interdit d’entrer en sectioncritique” respecte cette “specification”...Il faut ajouter une contrainte qui garantisse quetoute demande soit satisfaite.

pas de faminepas d’interblocage (etreinte fatale)

Cette satisfaction peut etre precisee :l’ordre de satisfaction doit etre le meme que l’ordre dedemande d’entreeune certaine equite est requisel’attente est bornee...


Exclusion Mutuelle

Famine

DefinitionAucune garantie pour un thread d’avoir l’acces a lasection critique qu’il demande.

⇒ Algorithme d’exclusion mutuelle non equitable.


Exclusion Mutuelle

Interblocage (Etreinte fatale)

DefinitionL’interblocage se produit lorsque deux processusconcurrents s’attendent mutuellement. Les processusbloques dans cet etat le sont definitivement, il s’agitdonc d’une situation catastrophique.


Exclusion Mutuelle

Exemple d’interblocage

Exemple :Thread 1 Thread 2

Obtenir M1 Obtenir M2Obtenir M2 Obtenir M1section critique section critiqueRendre M2 Rendre M1Rendre M1 Rendre M2

Le Thread 1 obtient M1.Le Thread 2 obtient M2.Les deux attendent la ressource obtenue par l’autre


Exclusion Mutuelle

Dıner des philosophes

cinq philosophes, chacun a un plat de spaghetti etune fourchette a gauche3 etats : affame, penseur, mangeurpour manger on a besoin des deux fourchettes


Exclusion Mutuelle

Specification du Probleme de l’ExclusionMutuelle

Etant donnes des sections critiques (SC), un algorithmed’exclusion mutuelle doit satisfaire :

1 exclusion mutuelle (EM) : si un thread est enSC, aucun autre thread ne peut y etre.

2 progres (P) : si un groupe de thread demande aentrer en SC, l’un d’eux doit obtenir d’entrer en SC

3 equite (E) : tout thread demandant a entrer enSC doit y entrer ( au bout d’un certain temps)


Exclusion Mutuelle

Surete et Vivacite

EM est une contrainte de sureteP et E sont des contraintes de vivacite

P =⇒ pas d’etreinte fataleE =⇒ pas de famine

Les algorithmes d’exclusion mutuelle sont des compromisentre surete et vivacite...


Exclusion Mutuelle

Garantir l’Exclusion Mutuelle

Pour mettre en place de l’exclusion mutuelle, il existe denombreux outils :

conditions variables

moniteurs

semaphores

...


Exclusion Mutuelle

Les Conditions Variables

Boucle sur une condition (partagee)

while ( condition ); // boucle infinie

// sur condition partagee


NB : attente active


Exclusion Mutuelle

Moniteurs

Un mecanisme supplementaire evitant l’attente active

if ( condition )

wait(); // Appel bloquant


notify(); //reveil d’un thread bloque

Seul mecanisme avec synchronized pour Java < 1.5


Exclusion Mutuelle

Semaphores

Une generalisation de la notion de verrou

P(sem); // acquerir le semaphore sem


V(sem); // liberer le semaphore sem


Exclusion Mutuelle

Implementation

Comment mettre en place ces outils et les primitivesassociees?... ou “Peut-on se passer de synchronized en Java?”

On supposera dans la suite que la lecture et l’ecriture enmemoire est atomique pour les types simples (ce qui estpresque vrai en Java).


Exclusion Mutuelle

Premiere Tentative I

Une variable partagee tour designe le thread dont c’estle tour :

static volatile Thread tour = null;

Cette variable est utilisee pour verifier si l’on peut entreren section critique ou s’il faut attendre.

public void Acquerir () {

while (tour != Thread.currentThread ()) {

if (tour == null) // la voie est libre

tour = Thread.currentThread ();

}

}


Exclusion Mutuelle

Premiere Tentative II

On remet tour a null en sortant de la section critique.

public void Liberer () {

tour = null;

}

Chaque thread execute une boucle infinie de tentatived’acces a la section critique :


Exclusion Mutuelle

Premiere Tentative III

public void run() {

while(true) {

Acquerir ();

// Section critique

System.out.println("C’est le tour de "+

Thread.currentThread (). getName ());

try { Thread.sleep((int)(Math.random ()*200));

} catch (Exception e) {}

System.out.println(" Fin du tour de "+

Thread.currentThread (). getName ());

Liberer ();

try { Thread.sleep((int)(Math.random ()*400));

} catch (Exception e) {}

}

}


Exclusion Mutuelle

Premiere Tentative IV

Mais ce code ne verifie EM.

⇐= considerer une execution synchrone...


Exclusion Mutuelle

Deux processus I

On va commencer avec uniquement deux processus.

ExclusionMutuelle.java : classe abstraiteExclusionMutuelle

Tache.java : classe definissant des threadseffectuant une boucle infinie de tentativesd’acces/sortie de section critique

Test.java : definition du main : creation des deuxthreads et leur demarrage.


Exclusion Mutuelle

Algorithme1.java I

public class Algorithme1

extends ExclusionMutuelle{

public Algorithme1 () {

turn = 0;

}

public void Pmutex(int t) {

while (turn != t)

Thread.yield ();

}

public void Vmutex(int t) {

turn = 1-t;

}

private volatile int turn;

}


Exclusion Mutuelle

Algorithme1.java II

Le probleme est que la condition P n’est pas verifiee : eneffet, seule une execution en tourniquet est possible.

En outre, il a ete prouve que pour n processus, il faut aumoins n variables partagees.


Exclusion Mutuelle

Deux Variables : l’Etat des Processus I

public class Algorithme2

extends MutualExclusion

{


flag [0] = false;

flag [1] = false;

}


int other;

other = 1-t;

flag[t] = true;

while (flag[other] == true)

Thread.yield ();


Exclusion Mutuelle

Deux Variables : l’Etat des Processus II

}


flag[t] = false;

}

private volatile boolean [] flag

= new boolean [2];

}


Exclusion Mutuelle

Deux Variables : l’Etat des Processus III

Considerons Algorithme2.java

La condition EM n’est pas verifiee.Considerons l’execution :

thread 0 thread 1 flag[t] flag[other]

flag[1]=false?: OUI flag[0]=false?: OUI false false

flag[0]:= true flag[1]:=true true true

Section Critique Section Critique - -

Si on initialise a true, alors ce sont les conditions P et Equi ne sont pas verifiees.


Exclusion Mutuelle

public class Algorithme4 extends ExclusionMutuelle

{


flag [0] = false;

flag [1] = false;

}


int other;

other = 1-t;

flag[t] = true;

while (flag[other] == true) {

flag[t] = false;

while (flag[other])

Thread.yield ();

flag[t] = true;

}


flag[t] = false;

}

private volatile boolean [] flag = new boolean [2];

}


Exclusion Mutuelle

Algorithme4.java

Une execution synchrone provoque un etreinte fatale...=⇒ regle de politesse


Exclusion Mutuelle

public class Dekker extends ExclusionMutuelle{

public Dekker () {

flag [0] = false;

flag [1] = false;

turn = 0;

}


int other;

other = 1-t;

flag[t] = true;

while (flag[other] == true)

if (turn == other) {

flag[t] = false;

while (turn == other)

Thread.yield ();

flag[t] = true;

}

}


turn = 1-t;

flag[t] = false;

}



}Arnaud Labourel (Universite de Provence) Exclusion Mutuelle 9 fevrier 2011 29 / 53

Exclusion Mutuelle

Dekker (1965)

L’equite est verifiee si l’ordonnanceur sous-jacent estequitable.


Exclusion Mutuelle

public class Peterson extends ExclusionMutuelle{

public Peterson () {

flag [0] = false;

flag [1] = false;

turn = 0;

}


int other;

other = 1-t;

flag[t] = true;

turn = t;

while (flag[other] && (turn == t))

Thread.yield ();

}


flag[t] = false;

}



}


Exclusion Mutuelle

Peterson (1981)

Cet algorithme est bien une solution au probleme del’exclusion mutuelle.

Comment s’en convaincre reellement apres toutes nosprecedentes et infructueuses tentatives ?


Exclusion Mutuelle

Correction d’Algorithmes Distribues

Correction d’algorithme necessaire

fiabilite ( pas d’etreinte fatale )securite ( =⇒ pas de faille de type “race condition” )

Algorithme = objet mathematique ( cf Cours LDP )

=⇒ preuve formelle

Algorithme distribue : encore plus difficile

Methode d’annotation du code Hoare ( 1969 ) puisOwicki, Gries (1975),


Exclusion Mutuelle

Principe

On associe a chaque transition du programme deuxformules logiques. Ces formules expriment des invariantsen ce point du programme.

{p}Instruction ;

{q}

Si la formule p est vraie, alors apres execution deInstruction, la formule q doit aussi etre vraie.

On infere ainsi logiquement le comportement correct duprogramme.


Exclusion Mutuelle

Exemple d’Annotations

G. Winskel. The formal semantics of programminglanguages. The MIT Press, 1993.

{x = x0 ∧ y = y0}q = 0;

while (x >= y) {{x = x0 − qy0 ∧ y = y0}q = q+1;

{x = x0 − (q − 1)y0 ∧ y = y0}x = x-y;

{x = x0 − qy0 ∧ y = y0}}

{x = x0 − qy0 ∧ x < y ∧ y = y0}Arnaud Labourel (Universite de Provence) Exclusion Mutuelle 9 fevrier 2011 35 / 53

Exclusion Mutuelle

Non-Interference

Attention Une fois la preuve faite pour le cas sequentiel(ie. un thread), il faut prouver que les invariants restentbien invariants si un autre thread s’execute entre deuxinstructions.

Les hypotheses sur le modele sont preponderantes

Quelles sont les operations atomiques?

=⇒ il faut rajouter des variables correspondant aupoint de controle du programme.

Il s’agit en general plus de non-interference des preuvesque des executions ...


Exclusion Mutuelle

Exemple d’Annotations pour laNon-Interference

{x = x0 ∧ y = y0 ∧ c = 0}q = 0;

while (x >= y) {{x = x0 − qy0 ∧ y = y0 ∧ c = 1}q = q+1;

{x = x0 − (q − 1)y0 ∧ y = y0 ∧ c = 2}x = x-y;

{x = x0 − qy0 ∧ y = y0 ∧ c = 3}}

{x = x0 − qy0 ∧ x < y ∧ y = y0 ∧ c = 4}


Exclusion Mutuelle

Conditions de Non-Interferences

On a

les processeurs Pi

la k−ieme instruction Ikles preconditions preik et postconditions postik (bienentendu postik = preik+1 )

alors la condition de non-interference signifie que chaqueinstruction Ijl ne peut alterer preik .


Exclusion Mutuelle

Conditions de Non-Interferences

On doit donc verifier, si Ijl = x=u; :

en terme de triplet de Hoare,

{preik ∧ prejl}x = u ;

{preik}

en terme logique,

preik ∧ prejl =⇒ preik [x ←− u]


Exclusion Mutuelle

Simplification pour Peterson

Comme il y a ici une seule variable partagee on simplifieen ne numerotant pas toutes les instructions.

On introduit deux variables auxiliaires after[0] etafter[1]

=⇒ vrai si le controle est apres l’instruction turn = t;

(t = 0, 1).On rajoute after[t]= true; apres celle-ci.


Exclusion Mutuelle

Notations

On note

I0 = {turn = 0}I1 = {turn = 1}preSC0 ={flag0 ∧ after0 ∧ (¬(flag1 ∧ after1) ∨ turn = 1)}preSC1 ={flag1 ∧ after1 ∧ (¬(flag0 ∧ after0) ∨ turn = 0)}


Exclusion Mutuelle

Peterson pour le Thread 0

{¬flag0}flag [0]= true; after [0]= false;

{flag0 ∧ ¬after0}turn =0; after [0]= true;

{flag0 ∧ after0 ∧ I0}while (flag [1] && (turn ==0)) do

{flag0 ∧ after0 ∧ I0}Thread.yield ();

{flag0 ∧ after0 ∧ (¬(flag1 ∧ after1) ∨ turn = 1)}[ Section Critique CS0]

{flag0}flag [0]= false;


Exclusion Mutuelle

Peterson pour le Thread 1



{flag1 ∧ after1 ∧ I1}while (flag [0] && (turn ==1)) do

{flag1 ∧ after1 ∧ I1}Thread.yield ();




Exclusion Mutuelle

Preuve de Correction I

En sequentiel : OK

Non-interference :Il y a un probleme a la troisieme assertion=⇒ on remplace I0 et I1 par I ={turn = 0 ∨ turn = 1}


Exclusion Mutuelle

Peterson pour le Thread 0 (version 2)



{flag0 ∧ after0 ∧ I}while (flag [1] && (turn ==0)) do

{flag0 ∧ after0 ∧ I}Thread.yield ();




Exclusion Mutuelle

Peterson pour le Thread 1 (version 2)



{flag1 ∧ after1 ∧ I}while (flag [0] && (turn ==1)) do

{flag1 ∧ after1 ∧ I}Thread.yield ();




Exclusion Mutuelle

Preuve de Correction I

Non-interference :Maintenant, seules les preSC contiennent des referencesmanipulees par l’autre thread (en premiere, deuxieme etderniere lignes)

→ Il reste a verifier la non interference pour preSC0


Exclusion Mutuelle

Preuve de Correction IIpreSC0 = flag0 ∧ after0 ∧ (¬(flag1 ∧ after1) ∨ turn = 1)

{preSC0 ∧ ¬flag1}flag [1]= true; after [1]= false;

{preSC0}

{preSC0 ∧ (flag1 ∧ ¬after1)}turn =1; after [1]= true;

{preSC0}

{preSC0 ∧ flag1}flag [1] = false;

{preSC0}


Exclusion Mutuelle

Preuve de Correction III

preSC0 = flag0 ∧ after0 ∧ (¬(flag1 ∧ after1) ∨ turn = 1)preSC1 = flag1 ∧ after1 ∧ (¬(flag0 ∧ after0) ∨ turn = 0)

Par symetrie, cela est aussi vrai pour le thread 1. Or

preSC0 ∧ preSC1 =⇒ turn = 0 ∧ turn = 1

Par consequent, on a bien l’exclusion mutuelle EM .


Exclusion Mutuelle

Et pour n Threads ?

Si on itere Peterson n − 1 fois on obtient une solution an threads. (cf PetersonN).


Exclusion Mutuelle

Peterson pour n Threads

turn of size nproc − 1flag = [-1,-1, ... , -1] of size nproc

for(j=0; j<nproc -1; j++)

flag[t]=j;

turn[j]=t;

cond =∨nproc−1

k=0 (flag [k] ≥ j)while (cond et turn[j] = t)

yield ();


Exclusion Mutuelle

public class PetersonN

{

private volatile int[] turn;

private int nproc;

private volatile int[] flag;

public PetersonN(int nb) {

int i;

nproc = nb;

turn = new int[nproc -1];

flag = new int[nproc];

for (i=0; i < nproc; i++) {

flag[i] = -1; }

}

}Arnaud Labourel (Universite de Provence) Exclusion Mutuelle 9 fevrier 2011 52 / 53

Exclusion Mutuelle

public class PetersonN{


int j, k;

boolean cond;

for (j=0; j < nproc -1; j++) {

flag[t] = j;

turn[j] = t;

cond = true;

for (k=0; (k < nproc) && (k != t); k++)

cond = cond || (flag[k] >= j);

while (cond && (turn[j] == t))

Thread.yield ();

}

}


flag[t] = -1;

}

}


exclusion mutuelle -...

Documents