Comprendre tout simplement » Sémaphore

Correction : Le Coiffeur fatigué

wafiwafi — Sun, 12 Jun 2011 15:38:27 +0000

On aura besoin de trois sémaphores pour protéger l’accès aux ressources partagées :
coiffeur : pour l’accès au coiffeur.
client : pour l’accès aux clients.
mutex : un sémaphore pour l’accès en exclusion mutuelle sur la variable partagée NbClientsEnAttente.

Exemple d’algorithme pour le problème du coiffeur fatigué :

initialisations :
sémaphore présence_client = 0 ; // le coiffeur dort au début; il est fatigué!
sémaphore coiffeur = 1 ; // pas de clients au début. Le coiffeur est disponible de suite.
Mais attention, il va falloir le réveiller!
sémaphore mutex = 1 ; // la variable NbClientsEnAttente est accesssible
entier NbClientsEnAttente = 0 ; // pas de clients au début

Processus coiffeur :

while (TRUE) {

//Le coiffeur demande une ressource appelée présence_client.
// Si un client est présent, il doit se réveiller. Sinon il poursuit sa sieste.

P(présence_client) ;

// A ce stade, le coiffeur est réveillé. Mais dans quel état?!
//On doit accéder la variable NbClientsEnAttente
//Si elle est prise, on attend. Sinon, on la décrémente car le client va quitter son siège //qui devient libre.

P(mutex) ;

// La variable est libérée. On décrémente.

NbClientsEnAttente=NbClientsEnAttente-1 ;

// le coiffeur est prêt à prendre en charge un client de la file d’attente.

V(coiffeur) ;

// Il doit libérer NbClientsEnAttente

V(mutex) ;

Coiffer() ;

}

Processus Client :

//un client qui arrive doit vérifier si tous les sièges sont pris.
// Il doit accéder à NbClientsEnAttente.

P(mutex) ;

//Vérifier s’il y a de la place ou pas.

if (NbClientsEnAttente < N) {

//il y a une place. Le client la prend mais doit incrémenter NbClientsEnAttente.

NbClientsEnAttente=NbClientsEnAttente+1 ;

// Une nouvelle ressource présence_client est disponible pour le coiffeur.
// C’est une manière de signaler votre présence au coiffeur.

V(présence_client) ;

// On doit libérer NbClientsEnAttente

V(mutex) ;

// Le client est pris en compte dans la file d’attente du coiffeur. Chacun à son tour !

P(coiffeur) ;

}

Else {

// Tous les sièges sont occupés. Le client libère NbClientsEnAttente

V(mutex) ;

//Le client s’en va.

Sortir_client() ;

}
}

Enoncé : Le coiffeur fatigué

wafiwafi — Sun, 12 Jun 2011 15:46:37 +0000

Dans un salon de coiffure, il y a un coiffeur C, un fauteuil F dans lequel se met le client pour être coiffé et N sièges pour attendre.
• S’il n’a pas de clients, le coiffeur C somnole dans le fauteuil F.
• Quand un client arrive et que le coiffeur C dort, il le réveille, C se lève. Le client s’assied dans F et se fait coiffer.
• Si un client arrive pendant que le coiffeur travaille :
o si un des N sièges est libre, il s’assied et attend,
o sinon il ressort.
A l’aide de sémaphores, proposez un algorithme permettant de synchroniser les activités du coiffeur et de ses clients.

Enoncé : Des babouins intelligents

wafiwafi — Sat, 11 Jun 2011 22:12:14 +0000

Un étudiant qui se spécialise en anthropologie et accessoirement en informatique s’est embarqué dans un projet de recherche pour voir s’il était possible d’enseigner les interblocages aux babouins d’Afrique. Il repère un profond canyon et y jette une corde au travers, de sorte que les babouins puissent le traverser à bout de bras. Plusieurs babouins peuvent traverser en même temps, pourvu qu’ils aillent tous dans la même direction. Si des babouins qui se dirigent vers l’est et d’autres vers l’ouest se trouvent sur la corde au même moment, cela conduit à un interblocage(les babouins sont bloqués au point de rencontre sur la corde) : en effet, ils n’ont pas la possibilité de passer les uns par-dessus les autres alors qu’ils sont suspendus au-dessus du canyon. Si un babouin souhaite traverser le canyon, il doit vérifier qu’aucun autre babouin ne traverse en sens inverse.
1. Au moyen de sémaphores, écrivez un programme pour éviter l’interblocage. Ne traitez pas le cas d’un groupe infini de babouins se déplaçant d’un côté et interdisant tout passage à ceux qui se déplacent vers l’autre côté.
2. Reprenez la question précédente, mais en évitant la privation de ressources (famine). Lorsqu’un babouin qui souhaite traverser le canyon vers l’est arrive à la corde et trouve un babouin qui traverse vers l’ouest, il attend jusqu’à ce que la corde soit vide, mais aucun babouin se déplaçant vers l’ouest n’est autorisé à démarrer jusqu’à ce qu’au moins un babouin ait traversé dans l’autre sens.

Corrigé : Des babouins intelligents

wafiwafi — Sat, 11 Jun 2011 16:34:52 +0000

1-
Un babouin qui se présente pour traverser doit d’abord passer par un processus de gestion.
Il formule sa demande. Soit elle est mise dans une file d’attente d’un sémaphore appelé gestion_est, soit elle est prise en compte directement si la ressource gestion_est est disponible.

P(gestion_est)

C’est tout de même un babouin de plus! il faut donc incrémenter le nombre de babouins (nb_babouin_est) dont les demandes ont été formulées.

nb_babouin_est ++

On doit tester s’il s’agit du premier babouin. Dans ce cas, il doit demander la ressource corde. Si c’est le premier, la variable nb_babouin_est sera égale à 1.

si nb_babouin_est == 1 alors P(corde)

La demande de la corde du premier babouin est dans la file d’attente du sémaphore corde. Il ne peut l’avoir que si la corde est libérée par l’ordre V(corde).

Dès que la corde est libérée, le premier babouin réquisitionne la corde; il ne la rendra que si tous les babouins de l’est traversent. Ces derniers n’ont pas besoin de demander la corde, ils peuvent traverser directement. Un babouin qui n’est pas de l’est ne peut traverser puisque la corde n’est pas rendue libre.
Les babouins de l’ouest doivent attendre!

Une fois un babouin est pris en compte, il doit immédiatement libérer la ressource gestion_est pour les autres babouins_est qui arrivent. il n’attendra pas la fin de sa traversée.

Mis à part le premier babouin, tous les babouins_est peuvent traverser sans se préoccuper de la ressource corde!
Néanmoins, il est important de noter que la ressource gestion_est détenue par le premier babouin ne peut être libérée que si ce dernier obtient la ressource corde. Tous les babouins_est sont dans ce cas en attente.

V(gestion_est)
traverser()

Mais il faut repérer la fin de traversée du dernier babouin pour libérer la ressource corde pour une autre vague de babouin (est ou ouest). Dans ce cas la file d’attente est forcément nulle.

On est tenté à écrire :

nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)

Cela voudrait dire qu’une fois un babouin a traversé, le nombre de babouins doit être décrémenté. Si on arrive à la valeur 0, ça sera forcément le dernier babouin; on doit donc rendre la corde.
Mais il se pose un problème :
Imaginons qu’à l’instant t le denier babouin est entrain de terminer sa traversée.
A cette même instant, un autre babouin_est prend la ressource gestion_est, il lit la variable nb_babouin qui est à 1 qui n’est pas encore incrémenté. Puis son processus est endormi par le système.
Ensuite, le dernier babouin rend la ressource corde après avoir décrémenté la variable nb_babouin_est qui est à 0. Admettons qu’ensuite un babouin ouest la saisi puis commence à traverser.

Au moment ou le processus endormis se réveille, la valeur nb_babouin est erronée et le babouin en question se met à traverser sans avoir besoin de la ressource corde puis qu’il ne se considère pas comme premier mais plutôt second. Il peut se trouver nez à nez avec le baboin ouest . On n’a pas l’air malin!

C’est pour ce type de problème qu’on va faire en sorte qu’après chaque arrivée de babouin, de rendre la ressource gestion_est occupée.Dans ce cas aucun babouin_est n’est pris en compte; il doit attendre. Une fois le test passé on rend la gestion_est libre, peut être pour un autre groupe de babouins de l’est ou encore un groupe de babouins de l’ouest.

P(gestion_est)
nb_babouin_est –-
si nb_babouin_est == 0 alors V(corde)
V(gestion_est)

Il en est de même pour le sémaphore gestion_ouest.

2-
Jusqu’au là, nous ne sommes pas à l’abri de la famine car si des babouins sont engagés, il n’y a aucune garantie pour ceux de l’autre côté de passer un jour.
Pour remédier à cette dernière, il faut modifier l’algorithme en ajoutant un sémaphore ordre_arrivee autour du protocole d’entrée. C’est donc le système qui gère la file d’attente de ceux ayant demandé la ressource qui garantira le respect de l’ordre des demandes.

Le code est donc le suivant :

P(ordre_arrivée)
P(gestion_est)
nb_babouin_est ++
si nb_babouin_est == 1 alors
P(corde)
V(gestion_est)
V(ordre_arrivée)
traverser()
P(gestion_est)
nb_babouin_est --
si nb_babouin_est == 0 alors
V(corde)
V(gestion_est)

Dès qu’un babouin de l’Est ou de l’Ouest prend la ressource ordre, son processus s’exécute. Il la rend dès qu’il s’apprête à traverser juste après avoir rendu la ressource gestion. C’est le babouin suivant dans la file d’attente du sémaphore ordre_arrivée qui voit son processus s’exécuter; Il peut s’agir d’un babouin_est ou d’un babouin_ouest.
La famine est irradiée!