1x1 - fil - Université Lille 1

Transcription

Synchronisation de
processus
Énoncé du problème
Section critique
Solutions partielles
Problèmes classiques
Philosophes chinois
Producteur –
consommateur
Rédacteurs – lecteurs
Synchronisation de processus
Sémaphore
Solution aux
problèmes classiques
Producteur –
consommateur
Lecteurs – rédacteurs
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V-2 (24-02-2012)
Licence miage — Université Lille 1
Pour toutes remarques : [email protected]
Semestre 6 — 2012-2013
www.fil.univ-lille1.fr/˜sedoglav/OS/Cours07.pdf
Synchronisation de
processus
Effet de l’ordonnancement
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Le segment de code d’un processus est constitué de plusieurs
instructions. Par exemple, on peut considérer un processus A dont
les instructions constituant le code seraient :
IA1
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’entrée-sortie, le processeur
exécute les instructions par intermittence :
IB1
V75 (24-02-2012)
IA2
IA1
IA2
IB2
IB3
IB4
IA3
...
Synchronisation de
processus
Section critique
Problème de concurrence
Considérons une ressource — ici une variable int cpt=2000 —
que l’on désire mettre à 1000 en utilisant 2 processus (qui sont
supposés se partager la ressource) :
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
EA1
EA2
EA3
EA4
processus A
charger(varA2,1000)
charger(varA1,cpt)
resA=add(varA1,varA2)
ranger(resA,cpt)
EB1
EB2
EB3
EB4
processus B
charger(varB2,2000)
charger(varB1,cpt)
resB=sub(varB1,varB2)
ranger(resB,cpt)
Supposons que l’on ait la succession d’actions :
EB1, EB2, EA1, EA2, EA3, EA4, EB3, EB4,
le résultat de cette séquence est cpt=0.
Supposons que l’on ait la succession d’actions :
EB1, EA1, EA2, EB2, EA3, EB3, EB4, EA4,
cette fois le résultat de cette séquence est cpt=3000.
V75 (24-02-2012)
Synchronisation de
processus
Notion de section critique : définition
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
La mise-à-jour de cpt doit s’effectuer à l’exclusion de toute autre
action : il s’agit d’une section critique. Un seul processus à la fois
peut modifier cpt ; l’autre doit attendre que le processus en cours
ait fini.
De plus, ces opérations ne peuvent se faire dans n’importe quel
ordre.
Peut importe l’ordre dans lequel se font les instructions EA1 et
EB1 ; 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.
Problème : comment coordonner ces sections critiques ?
Solution : exclusion mutuelle. Il nous suffit d’exclure l’exécution
d’une section critique par un processus pendant qu’un autre peut
effectuer cette exécution.
V75 (24-02-2012)
Synchronisation de
processus
Solution logiciel (fausse puis vrai) :
utilisation d’un verrou
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
On peut mettre un verrou sur la ressource.
Il s’agit d’une variable partagée par tous les processus.
Un processus doit tester ce verrou avant d’entrer en section
critique :
I
si le verrou est à 0, le processus le met à 1 et entre dans la
section critique ;
I
Si le verrou est à 1, le processus attend qu’il soit à 0 pour
s’emparer de la ressource.
Problème : si un processus voit le verrou à 0 et s’endort avant de
le mettre à 1, un autre processus peut se mettre sur les rangs et
lui ravir la ressource.
Lors du réveil du premier processus, celui-ci croit la ressource à sa
disposition et entre en section critique alors que le second
processus y est déjà. Le verrou constitue une ressource partagée.
Synchronisation de
processus
Illustration
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Considérons l’utilisation d’un seul booléen initialisé à vrai (C :=
vrai) qui est une ressource partagée par deux processus :
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
EA1
EA11
EA12
SCA
EA5
processus A
charger(varA2,1000)
tant que non C attendre
C := faux
Section Critique
C := vrai
EB1
EB11
EB12
SCB
EB5
processus B
charger(varB2,2000)
tant que non C attendre
C := faux
Section Critique
C := vrai
Synchronisation de
processus
Solution logiciel correcte : algorithme de
Deckker
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
On peut assurer l’alternance grâce à une variable tour commune à
tous les processus et initialisée à 0.
Si tour est égal à i alors le processus i est autorisé à exécuter sa
section critique.
Les autres processus font une boucle basée sur un test sur tour et
attendent que leur tour arrive.
Pour le processus i, on a donc
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
while(1){
while(tour!=i) ; /* attendre */
section_critique() ;
tour = i + 1 ;
section_non_critique() ;
}
Combinaison du verrou et du tour : on peut combiner ces deux
approches.
V75 (24-02-2012)
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Comme précédemment, les processus A et B doivent partager des
variables qu’il faut initialiser comme suit :
int c[2];
int tour;
c[0] = FALSE;
c[1] = FALSE;
tour = 0;
On considère 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;
Inconvénient : même si le processus ne fait rien, il monopolise le
processeur. On peut aussi empêcher les interruptions afin de
monopoliser le processeur physiquement.
V75 (24-02-2012)
Synchronisation de
processus
Philosophes chinois
Section critique
Philosophes chinois
Producteur –
consommateur
Description du problème : cinq philosophes chinois sont assis
autour d’une table ronde. Chacun d’eux a devant lui un plat. Une
baguette sépare deux assiettes mitoyennes. Un philosophe partage
son temps entre deux actions : manger et penser.
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Lorsqu’un philosophe a faim, il tente de
s’emparer de deux baguettes ; s’il les obtient il mange un certain temps avant de
reposer ces baguettes et de se remettre à
penser.
Conséquence de la loi de Murphy : un philosophe peut ne
jamais avoir deux baguettes ; chaque philosophe peut en avoir une.
Objectif : organiser le comportement de chaque philosophe pour
éviter les privations et les blocages.
V75 (24-02-2012)
Synchronisation de
processus
Producteur – consommateur
Section critique
Philosophes chinois
Producteur –
consommateur
Dans ce problème, il existe des produits et des cases. Chaques
cases pouvant contenir un produit. De plus,
I
un producteur dispose de deux primitives :
produire(produit) et deposer(case,produit). Il ne
peut déposer son produit que si la case correspondante n’est
pas pleine ;
I
un consommateur dispose de deux primitives :
consommer(produit) et retirer(case,produit). Le
consommateur ne peut consommer que si la case est pleine.
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Les deux processus ne doivent pas accéder en même temps au
tampon.
Conséquences de la loi de Murphy : le producteur peut déposer
un produit alors que le consommateur n’a pas retiré le précédent
ou retirer un produit alors que le producteur n’a rien déposé.
Objectif : organiser les comportements des deux partenaires.
V75 (24-02-2012)
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Ce problème modélise les accès à une base de données : un
ensemble de processus tente constamment d’accéder à la base de
données soit pour écrire, soit pour lire des informations.
Afin d’assurer une certaine cohérence des données de la base, il
faut interdire l’accès (en lecture et en écriture) à l’ensemble des
processus, si un processus est en train de modifier la base (accède
à la base en mode écriture).
Par contre, plusieurs processus peuvent accéder à la base, en
même temps, en mode lecture.
Dans ce cadre :
I
les rédacteurs représentent les processus qui demandent des
accès en écriture à la base de données ;
I
les lecteurs représentent les processus qui demandent des
accès en lecture à la base de données.
Synchronisation de
processus
Définition et utilisation des sémaphores
Section critique
Philosophes chinois
Producteur –
consommateur
En 1965, Dijkstra introduit la notion de sémaphore ; cette
structure de donnée est composée :
I
d’un compteur pouvant prendre des valeurs entières
(négatives, positives ou nulles) ;
Sémaphore
I
Solution aux
I
d’une liste de processus en attente ;
deux primitives atomiques manipulant le sémaphore :
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
wait décrémente le compteur associé au sémaphore. Si sa valeur
est négative, le processus se bloque dans la file d’attente ;
signal incrémente le compteur associé au sémaphore. Si le compteur
est négatif ou nul, un processus est choisi dans la file
d’attente est devient actif.
Plusieurs terminologies sont utilisées :
wait
signal
down
up
P
V
Ces opérations sont ininterruptibles et ont lieu séquentiellement.
V75 (24-02-2012)
Synchronisation de
processus
Exclusion mutuelle
Section critique
Philosophes chinois
Producteur –
consommateur
l’accès à une ressource unique (fichier, variable, imprimante, etc).
Le sémaphore s est initialisé à 1.
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Utilisation : Chaque processus a une section critique où il utilise
la ressource. Dans ce cas, chacun peut utiliser le sémaphore
comme suit :
wait(s)
Section critique
signal(s)
Synchronisation de
processus
Synchronisation
Section critique
Philosophes chinois
Producteur –
consommateur
Dans ce cas, un processus doit en attendre un autre pour
continuer (ou commencer) son exécution.
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Le sémaphore s est initialisé à 0.
Utilisation : dans le cas de deux processus, le sémaphore est
manipulé comme suit :
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Processus 1
Section critique
signal(s) // réveil processus 2
Processus 2
wait(s) // attente processus 1
Section critique
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Les rendez-vous
Le rendez-vous est une généralisation de la synchronisation.
Un processus RDV doit attendre que n autres processus soient
parvenus à un endroit précis pour poursuivre son exécution.
Ceci fait, les autres processus poursuivent eux aussi leurs
exécutions.
On utilise :
I un sémaphore Ssync initialisé à 0
I un sémaphore mutex initialisé à 1
I un sémaphore Sattend initialisé à 0
I un entier nb initialisé à 0 (une ressource partagée).
Il ne reste plus qu’à programmer les processus :
Processus i
...
P(mutex) ;
nb = nb + 1 ;
si nb = n alors V(Ssync) ; nb = 0 ;
V(mutex) ;
P(Sattend) ;
...
Processus RdV
...
...
P(Ssync) ;
V(Sattend, n) ;
...
...
...
Synchronisation de
processus
Section critique
Le problème d’interblocage
Supposons que SemA et SemB soient deux sémaphores d’exclusion
mutuelle initialisés à 1 et que l’on dispose d’au moins deux
processus :
Philosophes chinois
Producteur –
consommateur
Processus i
P(semA) ;
P(semB) ;
Section critique
V(semB) ;
V(semA) ;
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Processus j
P(semB) ;
P(semA) ;
Section critique
V(semA) ;
V(semB) ;
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Il y a interblocage en programmant le problème des philosophes
par :
penser();
P(fourchette
P(fourchette
manger();
V(fourchette
V(fourchette
V75 (24-02-2012)
i);
(i+1) mod 5);
i);
(i+1) mod 5);
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Il existe deux remèdes différents pour s’affranchir des
interblocages :
1. Prévention :
I
I
exécuter les P() toujours dans le même ordre ;
déclarer quelles sont les ressources que l’on va utiliser et
utiliser un algorithme qui en tient compte.
2. Détection–Guérison :
2.1 construire le graphe des conflits (périodiquement) ;
2.2 si un circuit est trouvé alors il y a interblocage ;
2.3 tuer un processus puis effectuer les V() manquants.
Synchronisation de
processus
Producteur – consommateur
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
#define N 100 /* nombre de places dans le tampon */
semaphore_t mutex=sema_init(1); /* contr\ôle 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
}
}
*/
*/
*/
*/
*/
*/
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
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
}
}
*/
*/
*/
*/
*/
*/
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Pour contrôler les accès 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);
}
V75 (24-02-2012)
Synchronisation de
processus
Philosophes chinois
Section critique
Philosophes chinois
Producteur –
consommateur
#define
#define
#define
#define
#define
#define
N 5
GAUCHE(i-1)%N
DROITE(i+1)%N
penser 0
faim
1
manger 2
/* nombre de philosophes */
/* on construit un tore */
/* les actions du philosophe */
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
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) ;
}
}
Synchronisation de
processus
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
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)
{
down (&mutex) ;
etat[i] = faim ;
test(i) ;
up(&mutex) ;
down(s[i]);
}
|
|
|
|
|
|
|
|
void poser_baguettes(int i)
{
down(&mutex) ;
etat[i] = penser ;
test(GAUCHE(i)) ;
test(DROITE(i)) ;
up(&mutex) ;
}
Synchronisation de
processus
Primitive de manipulation des sémaphores
(System V)
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
Un sémaphore est
implanté dans linux
par la structure de
donnée ci-contre.
Un tableau de valeurs est associé
au sémaphore ainsi
qu’une file d’attente
sem queue.
sem undo permet de
rétablir le sémaphore
au cas ou le processus le manipulant est
corrompu.
Synchronisation de
processus
La primitive semget d’obtention de
sémaphore
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
#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 — supposée unique —
construite à partir d’un chemin d’accès et d’un entier. Cette clef
est associée à une ressource et permet de la désigner.
La fonction semget retourne l’identificateur d’un tableau de nsems
valeurs associées au sémaphore lui même associé à la clef key.
Une structure de données associée à un sémaphore est créée si le
drapeau semflg est IPC CREAT et qu’aucun sémaphore n’est
associé à la clef key.
V75 (24-02-2012)
Synchronisation de
processus
La primitive semctl de contrôle de
sémaphore
Section critique
#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;
} ;
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
L’entier cmd détermine l’action de la fonction semctl suivant les
valeurs :
I
IPC STAT copie les informations du semaphore dans arg.buf ;
I
IPC SET affecte les informations du semaphore à partir de
arg.buf ;
I
IPC RMID détruit le sémaphore.
Synchronisation de
processus
La primitive semop de manipulation de
sémaphore
Section critique
Philosophes chinois
Producteur –
consommateur
#include<sys/types.h> /* semid~: identificateur du s\’emaphore */
#include<sys/ipc.h>
/* nsops~: nb d’\’el\’ements du tableau de s\
#include<sys/sem.h>
int semop(int semid, struct sembuf *sops, unsigned nsops);
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
struct sembuf{
unsigned short int sem_num;
short int sem_op;
short int sem_flg;
};
L’action de l’appel semop dépend du champs sem op. S’il est :
I
I
I
V75 (24-02-2012)
/* semaphore number */
/* semaphore operation */
/* operation flag */
strictement positif : une opération up est exécutée sur le
sémaphore ;
strictement négatif : une opération down est exécutée sur le
sémaphore ;
nul : une opération d’attente est exécutée et se termine
quand l’ensemble des sémaphores désignés par dipc sont nul.
Synchronisation de
processus
Sémaphores de processus léger (sémaphore
POSIX)
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
La gestion des sémaphores conformémant à la norme POSIX se
fait par l’intermédiaire 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 légers (threads) et ne
peuvent donc pas servir à la communication de processus lourd.
V75 (24-02-2012)
Synchronisation de
processus
Autres méthodes de synchronisation que les
sémaphores : moniteurs et compteurs
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Au lieu de se servir de sémaphore, on peut regrouper l’ensemble
des sections critiques d’un Problème dans un module nommé
moniteur.
Ce moniteur est un ensemble de fonctions, de variables et de
structures de données qui permettent de manipuler une ressource.
Les processus peuvent appeler les fonctions du moniteur mais ne
peuvent accéder à sa structure interne.
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Pour assurer l’exclusion mutuelle, il suffit qu’à tout moment, il n’y
ait qu’un processus actif utilisant le moniteur. Pour ce faire, si un
processus actif utilise le moniteur, un processus appelant le
moniteur est bloqué. Lorsque le processus actif quitte le moniteur,
il le libère.
Les moniteurs existent dans les langages orientés objet (JAVA,
C++).
V75 (24-02-2012)
Synchronisation de
processus
Compteurs d’événements
Section critique
Philosophes chinois
Producteur –
consommateur
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
Un compteur peut être associé à un événement et indiqué le
nombre d’occurrences de cet événement.
Ce compteur peut servir à synchroniser des processus : un
processus attend jusqu’à ce qu’une valeur du compteur soit
atteinte.
Trois opérations doivent être définies pour chaque compteur :
I
eval(cpt) donne la valeur du compteur cpt ;
I
inc(int *cpt) incrémente la valeur de cpt. Attention,
l’exécution de cette fonction ne doit pas être interrompue ;
I
wait(cpt,val) attend que cpt dépasse la valeur val.
Un compteur d’événement peut être utilisé dans le problème du
producteur — consommateur.
V75 (24-02-2012)
Synchronisation de
processus
Section critique
Une solution du problème des producteurs
et consommateurs par compteur
d’événement
Philosophes chinois
Producteur –
consommateur
#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 */
Sémaphore
Solution aux
Producteur –
consommateur
Philosophes chinois
Compléments
Implantation des
sémaphores
Sémaphores et
threads
Moniteurs
V75 (24-02-2012)
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\ôts */
|
printf("objet consomm\\’e [%d]:
inc(&int) ;
|
pos, objet) ;
}
|
pos = (pos+1)%N ;
}
|
}
| }

1x1 - fil - Université Lille 1

Transcription

Documents pareils

Université d`Aix Marseille 1, Master de Mathématiques Analyse

CNAM CSC109 : Méthode des éléments finis TP 4 Fig. 1 – Solution

Extinction en temps fini des solutions de certains probl`emes

Canal direct

Théorie abélienne des tissus, Jean

jacques bernard - Hainaut Terre de Goûts

Concours d`entrée en Ingénierie, 2012 Nom : Prénom : Test des

Assemblage de génomes `a l`aide des réseaux de fonctions de coûts

Bon, Propre et Juste: le Manifeste Slow Food pour la Qualité Le

Examen 2008-2009