Chap6 Semaphores

Introduction
Structures définies dans le noyau

Appels systèmes
Problèmes classiques
Processus: les sémaphores
GUINKO Tonguim Ferdinand
IBAM, Université de Ouagadougou
15 décembre 2009
1/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Introduction
Appels systèmes
Matériel ayant servi à la conception de ce cours
http ://www.linuxhq.com/guides/LPG/node47.html
Samia Bouzefrane, Applications concurrentes : concepts et
outils Applications concurrentes : concepts et outils, CNAM,
http ://cedric.cnam.fr/ bouzefra
http ://mathieu147.11vm-
serv.net/cmsmadesimple/index.php ?page=programmation-
concurrente

Introduction
Appels systèmes
Sommaire
1 Introduction
2 Structures définies dans le noyau
3 Appels systèmes
4 Problèmes classiques

Introduction
Structures définies dans le noyau Définition
Appels systèmes Exemples
1 Introduction
2 Structures définies dans le noyau
3 Appels systèmes
4 Problèmes classiques

Introduction
Introduction
Qu’est ce qu’un sémaphore ?

Définition
Mécanisme, muni d’un compteur, de régulation des accès aux
ressources partagées. Ils fonctionnent comme un mécanisme de
verrou permettant de bloquer l’accès à une ressource déjà utilisée
par un autre processus.

Introduction
Exemple d’illustration 1 : cas de la barrière
La barrière permet de réguler le passage à une intersection par

exemple ; un certain nombres de véhicules automobiles passent
l’intersection puis la barrière se ferme, et s’ouvre à nouveau
quelques instants plus tard. Ici :
La barrière représente un sémaphore ;
Les véhicules automobiles représentent les processus ;
L’intersection ou la voierie représente la ressource utilisée par
les processus, c’est à dire les véhicules automobiles.

Introduction
Exemple d’illustration 2 : cas des toilettes
Devant un pool de 7 toilettes, se tient une file d’attente de

personnes attendant leur tour pour utiliser un box de toilettes ; le
gestionnaire du pool de toilettes est assis à l’entrée et régule la file
d’attente ; il délivre à chaque personne, à tour de rôle, un ticket lui
permettant d’accéder aux toilettes dès qu’un box est libéré. A la
sortie du pool de toilettes, l’usager remet son ticket au gestion du
pool. Ici :
Le gestionnaire du pool de toilettes joue le rôle d’un
sémaphore ;
Les usagers jouent le rôle des processus ;
Les toilettes consituent alors les ressources qu’utilisent les
processus, c’est à dire les usagers.

Introduction
Exemple d’illustration 3 : cas du sac et des jetons
Un sémaphore peut être considéré comme un sac de jetons d’où

l’on retire un jetons, ou dans lequel on remet un jeton. Un
processus demandant un jeton doit attendre qu’il y en ait un de
disponible. Tout processus déposant un jeton doit réveiller le
processus le plus prioritaire en attente de jeton, s’il en existe. Ici :
Le sac : est le sémaphore
Les jetons : les autorisations délivrées par le sémaphore.

Introduction
Exemple d’illustration 4 : cas du pool d’impression
Considérons le cas d’un pool d’impression d’une grande entreprise

capable de gérer plusieurs imprimantes, chaque imprimante
pouvant gérer à son tour plusieurs requêtes. Le gestionnaire du
pool d’impression utilisera des sémaphore pour contrôler l’accès à
chaque imprimante. Le pool d’impression gère 5 imprimantes
toutes actives. Le gestionnaire du pool d’impression utilisera donc
un ensemble de 5 sémaphores, à raison d’un sémaphore par
imprimante. Puisque chaque imprimante est seulement capable
d’exécuter une tâche d’impression à la fois, chacun des 5
sémaphores considéré sera initialisé à un.

Introduction
Exemple du pool d’impression (suite)
Djibril envoie une requête d’impression au gestionnaire

d’impression. Le gestionnaire d’impression vérifie l’état des
sémaphores et constate que le sémaphore N°1 a une valeur égale à
un (1). Avant l’envoi de la requête d’impression de Djibril, le
gestionnaire d’impression décrémente la valeur du sémaphore
concerné et met cette valeur à moins un (-1). Plus tard, la valeur
de ce sémaphore devient zéro (0), ce qui signifie que toutes les
ressources gérées par ce sémaphores sont entièrement utilisées.

Introduction
Exemple du pool d’impression (suite)
Si tous les cinq (5) sémaphores ont chacun une valeur égale à zéro
(0), cela signifie que les cinq (5) imprimantes sont toutes occupées
et qu’aucune n’est disponible. Aucune autre requête ne sera
envoyée à cette imprimante tant que la valeur du sémaphore sera
inférieure ou égale à 0. Après l’exécution de la tâche d’impression
de Djibril, le gestionnaire d’impression incrémentera la valeur du
sémaphore concerné à un (1), ce qui signifie qu’il a une ressource
disponible et en attente d’utilisation.

Introduction
Définition (suite)
Sémaphore binaire : Un sémaphore binaire n’a que deux états :

0 verrouillé (ou occupé),
1 déverrouillé (ou libre).
Sémaphore général : Un sémaphore général peut avoir un très
grand nombre d’états car il s’agit d’un compteur qui :
Décroı̂t d’une unité quand il est acquis (”verrouillé”) ;
Croı̂t d’une unité quand il est libéré (”déverrouillé”).
Quand il vaut zéro
un processus tentant de l’acquérir doit attendre qu’un autre
processus ait augmenté sa valeur ;
car il ne peut jamais devenir négatif.

Introduction
Appels systèmes
Sémaphores dans LINUX
Le système d’exploitation LINUX dispose de 2 structures

permettant de définir des sémaphores ; il s’agit des structures :
semid ds et
sem

Introduction
Appels systèmes
Structure semid ds
Structure de type semid ds, et définie dans la bibliothèque

linux/sem.h : /* Une structure semid ds pour chaque ensemble de
sémaphores dans le système */
struct semid_ds
{
struct ipc_perm sem_perm; /* (1) */
struct __sem *sem_base; /* (2) */
time_t sem_otime; /* (3) */
time_t sem_ctime; /* (4) */
unsigned short sem_nsems; /* (5) */
};

Introduction
Appels systèmes
Structure semid ds (suite)
Avec :
(1) : structure décrivant les droits - voir ipc.h
(2) : pointeur sur le premier sémaphore
(3) : date de la dernière opération PVZ
(4) : date de la dernière opération semctl
(5) : nombre de sémaphores de l’ens

Introduction
Appels systèmes
Structure sem
Le système stocke des informations pour chaque sémaphore dans
une structure sem :
struct sem
{
ushort semval; /* (1) */
pid_t sempid; /* (2) */
ushort semncnt; /* (3) */
ushort semzcnt; /* (4) */
kcondvar_t semncnt_cv;
kcondvar_t semzcnt_cv;
};
Avant de pouvoir être utilisé, un sémaphore doit d’abord être créé.

A la fin de son usage, il doit être détruit.
Introduction
Appels systèmes
Structure sem (suite)
Avec :
(1) : valeur du sémaphore
(2) : pid de la dernière opération
(3) : awaiting semval ¿ cval
(4) : awaiting semval = 0

Introduction
Obtenir l’identificateur d’un ensemble de sémaphores
Opérations de contrôle sur les ensembles de sémaphores
Appels systèmes
Opérations sur les sémaphores
Appels systèmes
3 appels systèmes pour la gestion des sémaphores, sous LINUX :

int semget() : Obtenir l’identificateur d’un ensemble de
sémaphores ;
int semctl() : Opérations de contrôle sur les sémaphores ;
int semop() : Opérations sur les sémaphores.

Introduction
Appels systèmes
Obtenir l’identificateur d’un ensemble de sémaphores :

semget()
int semget(key t key, int nsems, int semflag) ;
semget() :
Crée un ensemble de sémaphores ;
Permet d’accéder à un ensemble de sémaphores ;
Récupére l’identificateur d’un ensemble de sémaphore existant.
Parmètres de l’appel système semget() :
key est un entier qui est une sorte de nom du sémaphore,
permettant à tous les processus de le repérer. On l’obtient à
l’aide des appels getcwd() et ftok(). key peut prendre l’une ou
l’autre des 2 valeurs suivantes :
IPC CREAT : crée un ensemble de sémaphores s’il n’existe
pas encore dans le noyau.
IPC EXCL : échoue (si utilisé avec IPC CREAT) si
l’ensemble de sémaphore existe déjà ; garantit qu’il n’existe pas
de sémaphore est déjà accédé.
Introduction
Appels systèmes

semget() suite ...
int semget(key t key, int nsems, int semflg) ;

semflag défini les priorités d’accès à l’ensemble de
sémaphores. nsems désigne le nombre de sémaphores présents
dans l’ensemble.
nsems : nombre maximal de sémaphores dans l’ensemble
(nombre d’imprimantes dans l’exemple ci-dessous). Le nombre
maximum de sémaphore du noyau est défini dans linux/sem.h.

Introduction
Appels systèmes

semget() suite ...
L’appel système semget() retourne les valeurs suivantes :

un entier en cas de succès, représentant le semid (identifiant)
de l’ensemble de sémaphores ou
-1 en cas d’erreur. Erreurs possibles :
EACCESS (accès interdit)
EEXIST (ensemble déjà existant, impossible d’effectuer
l’action de création (IPC EXCL))
EIDRM (ensemble marqué pour suppression)
ENOENT (ensemble non existant)
ENOMEM (espace mémoire insuffisant pour créer un nouvel
ensemble)
ENOSPC (nombre maximum d’ensembles atteint)

Introduction
Appels systèmes
Exemple d’utilisation de l’appel système semget()
int ouverture_semaph_set(key_t keyval, int nombreMaxSem)

{
int sid;
if (! nombreMaxSems)
return(-1);
if((sid = semget(mykey, nombreMaxSems,
IPC_CREAT | 0660)) == -1)
{
return(-1);
}
return(sid);
}

Introduction
Appels systèmes
Exemple d’utilisation de l’appel système semget()
L’exemple précédent crée un ensemble de nombreMaxSems

sémaphores accessibles en lecture/écriture par tout processus.
Cette fonction retourne l’identifiant de l’ensemble de sémaphores
ou -1 en cas d’erreur.

Introduction
Appels systèmes
Opérations de contrôle sur les sémaphores : semctl()
int semctl(int semid, int semnum, int cmd, semun arg) ;

Cette fonction effectue l’opération de contrôle indiquée par
cmd sur l’ensemble de sémaphores (ou sur le semno-ième
sémaphore de l’ensemble) identifié par semid, (les sémaphores
sont numérotés à partir de zéro) ;
Cette fonction prend trois ou quatre arguments. Lorsqu’il y en
a quatre, l’appel est semctl(semid,semno,cmd,arg) ; où
l’argument arg est de type union semun.

Introduction
Appels systèmes
Opérations de contrôle sur les sémaphores : semctl() ...

suite
Valeurs retournées :
entier positif en cas de succès ;
-1 en cas d’erreur. Les codes d’erreurs retournés sont :
EACCES : le processus appelant n’a pas les privilèges
nécessaires pour exécuter la commande cmd ;
EFAULT : arg.buf ou arg.array pointent en dehors de l’espace
d’adressage accessible ;
EIDRM : l’ensemble de sémaphores a été supprimé ;
EINVAL : cmd ou semid a une valeur illégale ;

Introduction
Appels systèmes
Opérations de contrôle sur les sémaphores : semctl() ...

suite
Suite des codes d’erreurs retournés en cas d’erreur :

EPERM : l’argument cmd réclame les commandes IPC SET
ou IPC RMID mais l’UID effectif du processus appelant n’a
pas les privilèges adéquats ;
ERANGE : l’argument cmd réclame les commandes SETALL
ou SETVAL et la valeur de semval (pour l’ensemble ou pour
certains sémaphores) est inférieure à 0 ou supérieur à la valeur
SEMVMX.

Introduction
Appels systèmes
Opérations sur les sémaphores : semop()
int semop(int semid, struct sembuf *sops, size t nsops) ;

La fonction semop effectue des opérations sur les membres de
l’ensemble de sémaphores identifié par semid. Chacun des nsops
éléments dans le tableau pointé par sops indique une opération à
effectuer sur un sémaphore en utilisant une structure struct sembuf.
Valeurs renvoyées :
renvoie la valeur 0, s’il réussit et
-1 s’il échoue.

Introduction
Problème du dı̂nner des philosophes
Problème des producteurs et des consommateurs
Appels systèmes
Problème des lecteurs et des rédacteurs
Cet exemple modélise l’allocation de plusieurs ressources.

Introduction
Appels systèmes
Problème des producteurs et des consommateurs :

généralités
Cet exemple modélise la communication de 2 processus, par un

canal fiable :
Contexte
Deux processus se partagent un tampon de données de taille fixe
(N) initialement vide :
Un premier processus (le producteur ) produit des données et
les écrit dans la mémoire tampon ;
Un second processus (le consommateur) consomme les
données de la mémoire tampon en les lisant et en les
détruisant au fur et à mesure de leur lecture.

Introduction
Appels systèmes
Problème des producteurs et des consommateurs : suite
En effet, sur les systèmes multitâches, la charge de travail est

répartie entre les processus : certains jouent un rôle de production
et sont appelés producteurs tandis que les autres jouent un rôle de
consommation et sont appelés consommateurs. Les producteurs
produisent des objets (par exemple des évènements) et les stockent
dans des structures de données (par exemple la mémoire tampon).
Les consommateurs puisent dans cette mémoire tampon et
procèdent au traitement des évènements y stockés.

Introduction
Appels systèmes
Exemple 1
Un évènement peut être définit comme une action qui requière une
réponse d’un programme : un exemple d’évènement peut être par
exemple la pression d’une touche de clavier ou un mouvement de la
souris, provoquant l’envoi d’un block de données depuis le disque
dur ou alors l’envoi d’un paquet à travers le réseau.
Dans tous les cas, dans le cadre d’un évènement, un processus
producteur crée un objet évènement et le stocke dans la mémoire
des évènements ; les processus consommateur, appelés
gestionnaires d’évènements, retirent de cette mémoire les
évènements qui y sont stockés et les traitent.

Introduction
Appels systèmes
Producteurs et consommateurs : problèmes
Problèmes
Les problèmes surviennent lorsque :
Le producteur veut mettre des informations alors que la
mémoire tampon est déjà pleine et lorsque
Le consommateur tente de retirer une information alors que la
mémoire tampon est vide.

Introduction
Appels systèmes
Producteurs et consommateurs : contraintes

Producteurs et consommateurs : contraintes
Pendant l’ajout ou le retrait d’un évènement de la mémoire
tampon (buffer), l’état de la mémoire est instable : les
processus doivent donc y accéder en exclusion mutuelle ;
Si un processus consommateur arrive lorsque la mémoire
tampon est vide, il est bloqué (endormi) jusqu’à ce qu’un
producteur y ajoute un élément ;
Si un processus producteur arrive lorsque la mémoire tampon
est pleine, il est bloqué (endormi) jusqu’à ce qu’un
consommateur y retire un élément ;
Il ne faut pas interrompre un producteur qui met une valeur
dans la mémoire tampon ou un consommateur qui vient en
chercher : il faut définir un sémaphore mt pour protéger les
opérations sur la mémoire tampon ;
Introduction
Appels systèmes
Producteurs et consommateurs : hypothèses
La coopération implique des producteurs et des consommateurs qui

se partagent une mémoire tampon ou une voie de communication,
avec un nombre maximal, taille du tampon ou crédit de messages.
Le contrôle de flux freine les producteurs s’ils vont trop vite pour
les consommateurs.
Hypothèses
1 Les vitesses relatives des processus sont quelconques ;
2 Les priorités des processus sont quelconques ;
3 Tout processus met un temps fini pour déposer ou retirer un
message ; en particulier ni panne ni blocage perpétuel pendant
ces opérations.

Introduction
Appels systèmes
Producteurs et consommateurs : conséquences
Conséquences
1 Exclusion mutuelle d’accès aux messages (le message peut
être lu ou écrit en plusieurs opérations) ;
2 Le producteur s’arrête s’il veut déposer alors que le tampon
est plein. Il est réveillé quand cette condition n’est plus vraie ;
3 Le consommateur s’arrête s’il veut retirer alors que le tampon
est vide. Il est réveillé quand cette condition n’est plus vraie.

Introduction
Appels systèmes
Exemples
Exemple2
Un processus d’un site émetteur dans un réseau envoie des
messages à destination d’un processus d’un site récepteur ; celui-ci
doit être prêt à recevoir ces messages ; toutefois l’émetteur ne doit
pas les envoyer plus vite que le récepteur ne peut les recevoir. Il
faut assurer un contrôle de flux entre sites.
Exemple3
Un service de messagerie permet aux abonnés d’un réseau
d’envoyer du courrier électronique ; un abonné édite son courrier et
le dépose dans la boite aux lettres du destinataire, que celui-ci soit
en session ou non ; un abonné lit son courrier, que l’émetteur soit
ou non en session.

Introduction
Appels systèmes
Producteurs et consommateurs : algorithmes
//Producteurs //Consommateurs
Debut true → Debut true →
"Produire un élément"; wait(ed);
wait(pd); wait(mt);
wait(mt); "Retirer un élément";
"Déposer l’élément dans le tampon";
signal(mt);
signal(mt); signal(pd);
signal(ed) "Consommer l’élément"
Fin Fin

Introduction
Appels systèmes
Cet exemple modélise la compétition cohérente. La compétition

d’accès met en présence des processus lecteurs et des processus
rédacteurs qui se partagent des données. L’exemple des lecteurs et
des rédacteurs met en évidence des situations où plusieurs
processus concurrents tentent de lire et modifier une structure de
données ou un base de données (cas du fichier /etc/passwd par
exemple) ou un système de fichiers. La synchronisation (contrôle
de concurrence) garantit la cohérence des données lues.

Introduction
Appels systèmes
Lecteurs et rédacteurs : contraintes
Un ou plusieurs lecteurs peuvent exécuter leur section critique

simultanément ;
Les rédacteurs doivent avoir l’accès exclusif à leur section
critique.
Pour l’écriture, l’accès à la base doit se faire en exclusion
mutuelle : il faut donc utiliser un sémaphore binaire Verrou
initialisé à 1 pour contrôler l’accès à la base de données.

Introduction
Appels systèmes
Lecteurs et rédacteurs : contraintes (suite)
Pour la lecture, nous devons d’abord garantir qu’aucun

écrivain ne peut accéder à la base. Donc le premier lecteur
doit verrouiller la base en utilisant le Verrou. Par contre, les
autres lecteurs peuvent accéder sans problème. Pour la fin de
lecture, le dernier lecteur doit lever le Verrou. Nous devons
donc utiliser un compteur nb lect, initialisé à 0, permettant
de connaı̂tre le nombre de lecteurs accédant simultanément à
la base.
Pour la lecture toujours, un deuxième sémaphore binaire
Prem Dern Lect, initialisé à 1, garantissant que les
opérations sur nb lect s’exécutent en exclusion mutuelle.

Introduction
Appels systèmes
Lecteurs et rédacteurs : contraintes
Aucun autre processus lecteur ou rédacteur ne doit pouvoir accéder

à la base de données si un rédacteur y est déjà, et aucun autre
processus rédacteur ne doit pouvoir exécuter sa section critique si
un autre processus y est déjà.

Introduction
Appels systèmes
Producteurs et consommateurs : algorithmes
//Ecrivain //Lecteur
Début Début
Répéter Répéter
Début_écriture; Début_lecture;
Ecriture; Lecture;
Fin_écriture; Fin_lecture;
Fin Fin

Introduction
Appels systèmes
Exemples
Exemple1
Une entreprise veut gérer en temps réel une base d’informations ;
certains processus modifient cette base ou y font des adjonctions ;
d’autres processus ne font que la lire, sans modifications. On
souhaite avoir le maximum de concurrence pendant ces lectures.

Introduction
Appels systèmes
Exemples (suite)
Exemple2
Dans tout système informatique, on maintient de nombreux
catalogues pour répertorier les clients, les abonnés, les groupes
d’usagers, les utilisateurs en session, les autorisations diverses, les
processus, les ressources disponibles, les ressources en
maintenance,.... ; des processus mettent ces catalogues à jour, en
général à fréquence faible ; d’autres processus les lisent, en général
assez fréquemment ; pour une meilleure efficacité, il est souhaitable
de faire les lectures en parallèle.

Langue

Chap6 Semaphores

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Chap6 Semaphores

Titre original :

Transféré par

Droits d'auteur :

Titres liés

Introduction

Structures définies dans le noyau

Processus: les sémaphores

GUINKO Tonguim Ferdinand

IBAM, Université de Ouagadougou

1/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Matériel ayant servi à la conception de ce cours

2/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

2 Structures définies dans le noyau

3/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

2 Structures définies dans le noyau

4/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Qu’est ce qu’un sémaphore ?

4/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’illustration 1 : cas de la barrière

La barrière permet de réguler le passage à une intersection par

5/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’illustration 2 : cas des toilettes

Devant un pool de 7 toilettes, se tient une file d’attente de

6/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’illustration 3 : cas du sac et des jetons

Un sémaphore peut être considéré comme un sac de jetons d’où

7/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’illustration 4 : cas du pool d’impression

Considérons le cas d’un pool d’impression d’une grande entreprise

8/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple du pool d’impression (suite)

Djibril envoie une requête d’impression au gestionnaire

9/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple du pool d’impression (suite)

10/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Sémaphore binaire : Un sémaphore binaire n’a que deux états :

11/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Sémaphores dans LINUX

Le système d’exploitation LINUX dispose de 2 structures

12/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Structure de type semid ds, et définie dans la bibliothèque

13/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Structure semid ds (suite)

14/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Avant de pouvoir être utilisé, un sémaphore doit d’abord être créé.

Structure sem (suite)

16/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

3 appels systèmes pour la gestion des sémaphores, sous LINUX :

17/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Obtenir l’identificateur d’un ensemble de sémaphores :

Obtenir l’identificateur d’un ensemble de sémaphores :

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

19/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Obtenir l’identificateur d’un ensemble de sémaphores :

L’appel système semget() retourne les valeurs suivantes :

20/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’utilisation de l’appel système semget()

int ouverture_semaph_set(key_t keyval, int nombreMaxSem)

21/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Exemple d’utilisation de l’appel système semget()

L’exemple précédent crée un ensemble de nombreMaxSems

22/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Opérations de contrôle sur les sémaphores : semctl()

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

23/43 GUINKO Tonguim Ferdinand Processus: les sémaphores

Opérations de contrôle sur les sémaphores : semctl() ...

24/43 GUINKO Tonguim Ferdinand Processus: les sémaphores