Synchronisation de processus - fil.univ-lille1.frsedoglav/OS/Cours07.pdf · Semestre 6 | 2012-2013...

Synchronisation deprocessus

Enonce du probleme

Section critique

Solutions partielles

Problemes classiques

Philosophes chinois

Producteur –consommateur

Redacteurs – lecteurs

Semaphore

Solution auxproblemes classiques


Lecteurs – redacteurs

Philosophes chinois

Complements

Implantation dessemaphores

Semaphores etthreads

Moniteurs

Synchronisation de processus

Licence miage — Universite Lille 1Pour toutes remarques : [email protected]

Semestre 6 — 2012-2013

V-2 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf


Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Effet de l’ordonnancement

Le segment de code d’un processus est constitue de plusieursinstructions. Par exemple, on peut considerer un processus A dontles instructions constituant le code seraient :

IA1 IA2 IA3 IA4 IA5 IA6 IA7 . . .

et un processus B avec comme code les instructions :

IB1 IB2 IB3 IB4 IB5 IB6 IB7 . . .

Du fait d’interruption et d’attente d’entree-sortie, le processeurexecute les instructions par intermittence :

IB1 IA1 IA2 IB2 IB3 IB4 IA3 . . .

V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf


Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Probleme de concurrence

Considerons une ressource — ici une variable int cpt=2000 —que l’on desire mettre a 1000 en utilisant 2 processus (qui sontsupposes se partager la ressource) :

processus A processus B

EA1 charger(varA2,1000)EA2 charger(varA1,cpt)EA3 resA=add(varA1,varA2)EA4 ranger(resA,cpt)

EB1 charger(varB2,2000)EB2 charger(varB1,cpt)EB3 resB=sub(varB1,varB2)EB4 ranger(resB,cpt)

Supposons que l’on ait la succession d’actions :

EB1, EB2, EA1, EA2, EA3, EA4, EB3, EB4,

le resultat de cette sequence est cpt=0.

Supposons que l’on ait la succession d’actions :

EB1, EA1, EA2, EB2, EA3, EB3, EB4, EA4,

cette fois le resultat de cette sequence est cpt=3000.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Notion de section critique : definition

La mise-a-jour de cpt doit s’effectuer a l’exclusion de toute autreaction : il s’agit d’une section critique. Un seul processus a la foispeut modifier cpt ; l’autre doit attendre que le processus en coursait fini.

De plus, ces operations ne peuvent se faire dans n’importe quelordre.

Peut importe l’ordre dans lequel se font les instructions EA1 etEB1 ; ces instructions ne font pas partie de la section critique.SCA = EA2, EA3, EA4 forment la section critique du processus A.SCB = EB2, EB3, EB4 forment la section critique du processus B.

Probleme : comment coordonner ces sections critiques ?

Solution : exclusion mutuelle. Il nous suffit d’exclure l’executiond’une section critique par un processus pendant qu’un autre peuteffectuer cette execution.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Solution logiciel (fausse puis vrai) :utilisation d’un verrou

On peut mettre un verrou sur la ressource.

Il s’agit d’une variable partagee par tous les processus.

Un processus doit tester ce verrou avant d’entrer en sectioncritique :

I si le verrou est a 0, le processus le met a 1 et entre dans lasection critique ;

I Si le verrou est a 1, le processus attend qu’il soit a 0 pours’emparer de la ressource.

Probleme : si un processus voit le verrou a 0 et s’endort avant dele mettre a 1, un autre processus peut se mettre sur les rangs etlui ravir la ressource.Lors du reveil du premier processus, celui-ci croit la ressource a sadisposition et entre en section critique alors que le secondprocessus y est deja. Le verrou constitue une ressource partagee.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Illustration

Considerons l’utilisation d’un seul booleen initialise a vrai (C :=

vrai) qui est une ressource partagee par deux processus :

processus A processus B

EA1 charger(varA2,1000)EA11 tant que non C attendreEA12 C := fauxSCA Section CritiqueEA5 C := vrai

EB1 charger(varB2,2000)EB11 tant que non C attendreEB12 C := fauxSCB Section CritiqueEB5 C := vrai



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Solution logiciel correcte : algorithme deDeckker

On peut assurer l’alternance grace a une variable tour commune atous les processus et initialisee a 0.Si tour est egal a i alors le processus i est autorise a executer sasection critique.

Les autres processus font une boucle basee sur un test sur tour etattendent que leur tour arrive.

Pour le processus i , on a donc

while(1){

while(tour!=i) ; /* attendre */

section_critique() ;

tour = i + 1 ;

section_non_critique() ;

}

Combinaison du verrou et du tour : on peut combiner ces deuxapproches.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Comme precedemment, les processus A et B doivent partager desvariables qu’il faut initialiser comme suit :

int c[2];

int tour;

c[0] = FALSE;

c[1] = FALSE;

tour = 0;

On considere que i est associe au processus courant et j a l’autre

c[i] = TRUE;

tour = j;

while ((c[j]) && (tour == j)) {};

Section critique

c[i] = FALSE;

Inconvenient : meme si le processus ne fait rien, il monopolise leprocesseur. On peut aussi empecher les interruptions afin demonopoliser le processeur physiquement.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Philosophes chinois

Description du probleme : cinq philosophes chinois sont assisautour d’une table ronde. Chacun d’eux a devant lui un plat. Unebaguette separe deux assiettes mitoyennes. Un philosophe partageson temps entre deux actions : manger et penser.

Lorsqu’un philosophe a faim, il tente des’emparer de deux baguettes ; s’il les ob-tient il mange un certain temps avant dereposer ces baguettes et de se remettre apenser.

Consequence de la loi de Murphy : un philosophe peut nejamais avoir deux baguettes ; chaque philosophe peut en avoir une.

Objectif : organiser le comportement de chaque philosophe poureviter les privations et les blocages.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Producteur – consommateur

Dans ce probleme, il existe des produits et des cases. Chaquescases pouvant contenir un produit. De plus,

I un producteur dispose de deux primitives :produire(produit) et deposer(case,produit). Il nepeut deposer son produit que si la case correspondante n’estpas pleine ;

I un consommateur dispose de deux primitives :consommer(produit) et retirer(case,produit). Leconsommateur ne peut consommer que si la case est pleine.

Les deux processus ne doivent pas acceder en meme temps autampon.

Consequences de la loi de Murphy : le producteur peut deposerun produit alors que le consommateur n’a pas retire le precedentou retirer un produit alors que le producteur n’a rien depose.

Objectif : organiser les comportements des deux partenaires.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs


Ce probleme modelise les acces a une base de donnees : unensemble de processus tente constamment d’acceder a la base dedonnees soit pour ecrire, soit pour lire des informations.

Afin d’assurer une certaine coherence des donnees de la base, ilfaut interdire l’acces (en lecture et en ecriture) a l’ensemble desprocessus, si un processus est en train de modifier la base (accedea la base en mode ecriture).

Par contre, plusieurs processus peuvent acceder a la base, enmeme temps, en mode lecture.

Dans ce cadre :

I les redacteurs representent les processus qui demandent desacces en ecriture a la base de donnees ;

I les lecteurs representent les processus qui demandent desacces en lecture a la base de donnees.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Definition et utilisation des semaphores

En 1965, Dijkstra introduit la notion de semaphore ; cettestructure de donnee est composee :

I d’un compteur pouvant prendre des valeurs entieres(negatives, positives ou nulles) ;

I d’une liste de processus en attente ;

I deux primitives atomiques manipulant le semaphore :

wait decremente le compteur associe au semaphore. Si sa valeurest negative, le processus se bloque dans la file d’attente ;

signal incremente le compteur associe au semaphore. Si le compteurest negatif ou nul, un processus est choisi dans la filed’attente est devient actif.

Plusieurs terminologies sont utilisees :

wait down Psignal up V

Ces operations sont ininterruptibles et ont lieu sequentiellement.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Exclusion mutuelle

l’acces a une ressource unique (fichier, variable, imprimante, etc).Le semaphore s est initialise a 1.

Utilisation : Chaque processus a une section critique ou il utilisela ressource. Dans ce cas, chacun peut utiliser le semaphorecomme suit :

wait(s)Section critique

signal(s)



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Synchronisation

Dans ce cas, un processus doit en attendre un autre pourcontinuer (ou commencer) son execution.

Le semaphore s est initialise a 0.

Utilisation : dans le cas de deux processus, le semaphore estmanipule comme suit :

Processus 1 Processus 2Section critique wait(s) // attente processus 1

signal(s) // reveil processus 2 Section critique



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Les rendez-vousLe rendez-vous est une generalisation de la synchronisation.Un processus RDV doit attendre que n autres processus soientparvenus a un endroit precis pour poursuivre son execution.Ceci fait, les autres processus poursuivent eux aussi leursexecutions.On utilise :

I un semaphore Ssync initialise a 0I un semaphore mutex initialise a 1I un semaphore Sattend initialise a 0I un entier nb initialise a 0 (une ressource partagee).

Il ne reste plus qu’a programmer les processus :

Processus i Processus RdV. . . . . .

P(mutex) ; . . .nb = nb + 1 ; P(Ssync) ;

si nb = n alors V(Ssync) ; nb = 0 ; V(Sattend, n) ;V(mutex) ; . . .

P(Sattend) ; . . .. . . . . .



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Le probleme d’interblocage

Supposons que SemA et SemB soient deux semaphores d’exclusionmutuelle initialises a 1 et que l’on dispose d’au moins deuxprocessus :

Processus i Processus jP(semA) ; P(semB) ;P(semB) ; P(semA) ;

Section critique Section critiqueV(semB) ; V(semA) ;V(semA) ; V(semB) ;

Il y a interblocage en programmant le probleme des philosophespar :

penser();

P(fourchette i);

P(fourchette (i+1) mod 5);

manger();

V(fourchette i);

V(fourchette (i+1) mod 5);



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Il existe deux remedes differents pour s’affranchir desinterblocages :

1. Prevention :I executer les P() toujours dans le meme ordre ;I declarer quelles sont les ressources que l’on va utiliser et

utiliser un algorithme qui en tient compte.

2. Detection–Guerison :

2.1 construire le graphe des conflits (periodiquement) ;2.2 si un circuit est trouve alors il y a interblocage ;2.3 tuer un processus puis effectuer les V() manquants.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Producteur – consommateur

#define N 100 /* nombre de places dans le tampon */

semaphore_t mutex=sema_init(1); /* contr\^ole d acc\‘es au tampon */

semaphore_t vide =sema_init(N); /* nb de places libres */

semaphore_t plein=sema_init(0); /* nb de places occup\’ees */

void

producteur

(void)

{

objet_t objet ;

while (TRUE)

{

produire_objet (&objet) ; /* produire l’objet suivant */

down (&vide) ; /* d\’ec. nb places libres */

down (&mutex) ; /* entr\’ee en section critique */

mettre_objet (objet) ; /* mettre l’objet dans le tampon */

up (&mutex) ; /* sortie de section critique */

up (&plein) ; /* inc. nb places occup\’ees */

}

}



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

void

consommateur

(void)

{

objet_t objet ;

while (TRUE)

{

down (&plein) ; /* d\’ec. nb emplacements occup\’es */

down (&mutex) ; /* entr\’ee section critique */

retirer_objet (&objet) ; /* retire un objet du tampon */

up (&mutex) ; /* sortie de la section critique */

up (&vide) ; /* inc. nb emplacements libres */

utiliser_objet (objet) ; /* utiliser l’objet */

}

}



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Lecteurs – redacteursPour controler les acces a la base, on doit connaıtre le nombre nbl

de lecteur en train de lire.

unsigned int nbl = 0 ; /* c’est une ressource partag\’ee */

semaphore_t mutex=sema_init(1);/* contr\ôle d acc\‘es \‘a la base */

semaphore_t redac=sema_init(1);/* contr\ôle d acc\‘es \’ecrivain */

void lecteur (void)

{ do{

down(mutex) ;

if(!nbl) down(redac);/* le premier lecteur emp\êche l’\’ecriture */

nbl++ ;

up(mutex) ;

LectureDeLaBase() ;

down(mutex) ;

nbl-- ;

if(!nbl) up(redac);/* le dernier lecteur autorise l’\’ecriture */

up(mutex) ;

} while(1) ;

}

void redacteur(void){

do{down(redac); ModificationDeLaBase(); up(redac);} while(1);

}



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Philosophes chinois

#define N 5 /* nombre de philosophes */

#define GAUCHE(i-1)%N /* on construit un tore */

#define DROITE(i+1)%N

#define penser 0 /* les actions du philosophe */

#define faim 1

#define manger 2

typedef int semaphore ;

int etat[N] ; /* on suppose ce tableau initialis\’e */

semaphore mutex = 1 ; /* s\’emaphore d’exclusion mutelle */

semaphore s[N] ; /* un s\’emaphore est attach\’e

\‘a chaque philosope,

il est initialis\’e \‘a 0 */

void philosophe(int i){

while(1){

penser() ;

prendre_baguettes(i) ;

manger();

poser_baguettes(i) ;

}

}



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

void test(int i)

{

if ( etat[i] == faim

&& etat[GAUCHE(i)] != manger

&& etat[DROITE(i)] != manger ){

etat[i] = manger ;

up(s[i]) ;

}

}

void prendre_baguettes(int i) | void poser_baguettes(int i)

{ | {

down (&mutex) ; | down(&mutex) ;

etat[i] = faim ; | etat[i] = penser ;

test(i) ; | test(GAUCHE(i)) ;

up(&mutex) ; | test(DROITE(i)) ;

down(s[i]); | up(&mutex) ;

} | }



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Primitive de manipulation des semaphores(System V)

Un semaphore estimplante dans linuxpar la structure dedonnee ci-contre.

Un tableau de va-leurs est associeau semaphore ainsiqu’une file d’attentesem queue.

sem undo permet deretablir le semaphoreau cas ou le proces-sus le manipulant estcorrompu.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

La primitive semget d’obtention desemaphore

#include <sys/types.h>

#include <sys/ipc.h>

key_t ftok(const char *pathname, int proj_id);

#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

La fonction ftok retourne une clef — supposee unique —construite a partir d’un chemin d’acces et d’un entier. Cette clefest associee a une ressource et permet de la designer.

La fonction semget retourne l’identificateur d’un tableau de nsems

valeurs associees au semaphore lui meme associe a la clef key.

Une structure de donnees associee a un semaphore est creee si ledrapeau semflg est IPC CREAT et qu’aucun semaphore n’estassocie a la clef key.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

La primitive semctl de controle desemaphore

#include <sys/types.h>

#include <sys/ipc.h>

#include <sys/sem.h>

int semctl(int semid, int semnum, int cmd, union semun arg);

union semun {

int val;

unsigned short *array ;

struct semid_ds *buf;

struct seminfo *__buf;

} ;

L’entier cmd determine l’action de la fonction semctl suivant lesvaleurs :

I IPC STAT copie les informations du semaphore dans arg.buf ;

I IPC SET affecte les informations du semaphore a partir dearg.buf ;

I IPC RMID detruit le semaphore.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

La primitive semop de manipulation desemaphore

#include<sys/types.h> /* semid~: identificateur du s\’emaphore */

#include<sys/ipc.h> /* nsops~: nb d’\’el\’ements du tableau de s\’emaphores */

#include<sys/sem.h>

int semop(int semid, struct sembuf *sops, unsigned nsops);

struct sembuf{

unsigned short int sem_num; /* semaphore number */

short int sem_op; /* semaphore operation */

short int sem_flg; /* operation flag */

};

L’action de l’appel semop depend du champs sem op. S’il est :

I strictement positif : une operation up est executee sur lesemaphore ;

I strictement negatif : une operation down est executee sur lesemaphore ;

I nul : une operation d’attente est executee et se terminequand l’ensemble des semaphores designes par dipc sont nul.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Semaphores de processus leger (semaphorePOSIX)

La gestion des semaphores conformemant a la norme POSIX sefait par l’intermediaire des appels :

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

int sem_wait(sem_t * sem);

int sem_trywait(sem_t * sem);

int sem_post(sem_t * sem);

int sem_getvalue(sem_t * sem, int * sval);

int sem_destroy(sem_t * sem);

Ces appels ne s’appliquent qu’aux processus legers (threads) et nepeuvent donc pas servir a la communication de processus lourd.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Autres methodes de synchronisation que lessemaphores : moniteurs et compteurs

Au lieu de se servir de semaphore, on peut regrouper l’ensembledes sections critiques d’un Probleme dans un module nommemoniteur.

Ce moniteur est un ensemble de fonctions, de variables et destructures de donnees qui permettent de manipuler une ressource.

Les processus peuvent appeler les fonctions du moniteur mais nepeuvent acceder a sa structure interne.

Pour assurer l’exclusion mutuelle, il suffit qu’a tout moment, il n’yait qu’un processus actif utilisant le moniteur. Pour ce faire, si unprocessus actif utilise le moniteur, un processus appelant lemoniteur est bloque. Lorsque le processus actif quitte le moniteur,il le libere.

Les moniteurs existent dans les langages orientes objet (JAVA,C++).



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Compteurs d’evenements

Un compteur peut etre associe a un evenement et indique lenombre d’occurrences de cet evenement.Ce compteur peut servir a synchroniser des processus : unprocessus attend jusqu’a ce qu’une valeur du compteur soitatteinte.Trois operations doivent etre definies pour chaque compteur :

I eval(cpt) donne la valeur du compteur cpt ;

I inc(int *cpt) incremente la valeur de cpt. Attention,l’execution de cette fonction ne doit pas etre interrompue ;

I wait(cpt,val) attend que cpt depasse la valeur val.

Un compteur d’evenement peut etre utilise dans le probleme duproducteur — consommateur.



Enonce du probleme

Section critique



Philosophes chinois



Semaphore




Philosophes chinois

Complements



Moniteurs

Une solution du probleme des producteurset consommateurs par compteurd’evenement#define N 100 /* taille du tampon i.e. nb de cases */

int in = 0 ; /* incr\’ement\’e par le producteur */

int out = 0 ; /* incr\’ement\’e par le consommateur */

void producteur (void){ | void consommateur (void){

int objet, sequence=0, pos=0 ; | int objet, sequence=0, pos=0 ;

while(1){ | while(1){

objet++ ; | sequence++ ;

sequence++ ; | /* attendre que le tampon

/* attendre que le tampon | devienne non vide */

devienne non plein */ | wait(in,sequence) ;

wait(out, sequence-N) ; | objet = tampon[pos]

tampon[pos] = objet ; | /* incr\’ementer le compteur

pos = (pos+1)%N ; | de retraits */

/* incr\’ementer le nombre | inc(&out) ;

de d\’ep\^ots */ | printf("objet consomm\\’e [%d]:%d",

inc(&int) ; | pos, objet) ;

} | pos = (pos+1)%N ;

} | }

| }


Synchronisation de processus - fil.univ-lille1.frsedoglav/OS/Cours07.pdf · Semestre 6 | 2012-2013...

Documents

Transcript of Synchronisation de processus - fil.univ-lille1.frsedoglav/OS/Cours07.pdf · Semestre 6 | 2012-2013...