Post on 13-Sep-2018
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
Moniteurs
Synchronisation de processus
Licence miage — Universite Lille 1Pour toutes remarques : Alexandre.Sedoglavic@univ-lille1.fr
Semestre 6 — 2012-2013
V-2 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
Moniteurs
Redacteurs – lecteurs
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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)
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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) ; . . .. . . . . .
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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);
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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 */
}
}
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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 */
}
}
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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\^ole d acc\‘es \‘a la base */
semaphore_t redac=sema_init(1);/* contr\^ole d acc\‘es \’ecrivain */
void lecteur (void)
{ do{
down(mutex) ;
if(!nbl) down(redac);/* le premier lecteur emp\^eche 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);
}
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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) ;
}
}
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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) ;
} | }
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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++).
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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.
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation deprocessus
Enonce du probleme
Section critique
Solutions partielles
Problemes classiques
Philosophes chinois
Producteur –consommateur
Redacteurs – lecteurs
Semaphore
Solution auxproblemes classiques
Producteur –consommateur
Lecteurs – redacteurs
Philosophes chinois
Complements
Implantation dessemaphores
Semaphores etthreads
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 ;
} | }
| }
V75 (24-02-2012) www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf