• Aucun résultat trouvé

Th´eorie et pratique de la concurrence – Master 1 Informatique TP 2 : Les verrous en C

N/A
N/A
Protected

Academic year: 2022

Partager "Th´eorie et pratique de la concurrence – Master 1 Informatique TP 2 : Les verrous en C"

Copied!
2
0
0

Texte intégral

(1)

Th´ eorie et pratique de la concurrence – Master 1 Informatique TP 2 : Les verrous en C

Les mutexs

Lesmutexssont des verrous propos´es par la biblioth`equePthreads. Pour les utiliser, il faut inclure la biblioth`eque :

#include <pthread.h>

La d´eclaration d’unmutex se fait de la fa¸con suivante :

pthread_mutex_t verrou;

Pour initialiser unmutex, on proc`ede comme suit :

pthread_mutex_init (&verrou , NULL);

Le premier argument correspond au verrou que l’on souhaite initialiser, quand au second, qui est mis `a NULL, il pr´ecise les attributs du verrou.

Pour ”prendre un verrou” (i.e. faire P sur le verrou), on fait :

pthread_mutex_lock (&verrou);

Et pour le lib´erer :

pthread_mutex_unlock (&verrou);

Par cons´equent, une section critique pourra ˆetre faite de la fa¸con suivante :

pthread_mutex_lock (&verrou);

/*section critique*/

pthread_mutex_unlock(&verrou);

Exercices

Exercice1: La m´emoire partag´ee

Reprenez l’exercice 4 du Tp 1 et proposer une impl´ementation dans laquelle chaque donn´ee pro- duite par un producteur n’est lue que par au plus un consommateur.

Exercice2: Mauvaise manipulation de mutex

1. Proposez un programme avec deux threads et deux verrous et de telle sorte que les deux threads soient bloqu´es dans l’attente de verrous pris par l’autre thread.

2. Inventez un programme o`u un thread tente de lib´erer un verrou qui a ´et´e pris par un autre thread. Qu’observez-vous ?

Exercice3: Encore des producteurs-consommateurs

Proposez une impl´ementation d’un syst`eme de producteurs-consommateurs dans lequel la commu- nication se fait par file FIFO. Les r`egles sont les suivantes. Les producteurs ajoutent des entiers dans la file qui sont ensuite lus/retir´es par les consommateurs. Pour qu’un consommateur retire un entier de la file, il doit ˆetre sˆur que cet entier a ´et´e lu par tous les consommateurs.

(2)

La file FIFO devrait ˆetre repr´esent´ee par une liste simplement chaˆın´ee avec un pointeurtopsur le ebut de la liste (utilis´e par les consommateurs pour commencer `a lire des entiers de la file) et un pointeurtailsur la fin de la liste (utilis´e par les producteurs pour ajouter des entiers `a la file). La liste contiendra toujours un noeud sentinelle (qui n’est pas utilis´e pour stocker des entiers supposes

`

a ˆetre lus par les consommateurs) point´e au d´ebut par les deux pointeurs topet tail. De cette mani`ere, la file est vide quand top = tail. Les consommateurs lisent des entiers en parcourant la liste `a partir de top (notez que les consommateurs n’avancent pas n´ecessairement au mˆeme rythme). Ainsi, les entiers sont lus dans l’ordre qui sont ajout´es par les producteurs. Pour tester qu’un entier de la file a ´et´e lu par tous les consommateurs il faut ajouter un ou plusieurs champs aux noeuds de la liste.Faites attention aux modifications concurrentes de la file.

Exercice4: Le dˆıner des philosophes

Le probl`eme du dˆıner des philosophes est un probl`eme classique de partage des ressources en programmation concurrente. Ce probl`eme se r´esume ainsi. Il y anphilosophes assis autour d’une table. Chaque philosophe a devant lui une assiette de riz et pour manger il a besoin de deux baguettes. Il y a en toutnbaguettes qui se trouve `a la gauche de chaque assiette. Un philosophe se comporte de la fa¸con suivante : il pense, puis si il a envie de manger, il prend sa baguette gauche ensuite il prend sa baguette droite et quand il termine de manger, il rend les deux baguettes et il recommence `a penser et ainsi de suite.

Dans cet exercice on souhaite mod´eliser ce probl`eme du dˆıner des philosophes par un programme en C dans lequel chaque baguette sera repr´esent´ee par un verrou et chaque philosophe sera impl´ement´e par un thread.

1. Programmez votre solution et testez-la pour 5 philosophes.

2. Normalement votre solution devrait aboutir `a un interblocage des philosophes. Essayez d’exhiber cet interblocage.

3. Proposez des solutions (et programmez-les) pour r´esoudre cet interblocage ? (Indication : Il faut ´eliminer les entrelacements qui conduisent `a l’interblocage, soit en ajoutant de la coordination entre les philosophes soit en modifiant la strat´egie utilis´ee par les philosophes pour prendre les deux baguettes.) Vos solutions permettent-elles de garantir l’absence de famine pour un philosophe ?

Références

Documents relatifs

Pour cela, d´ eveloppez une solution qui laisse au plus entrer 4 voitures sur le pont, si une voiture qui va dans la direction oppos´ ee veut entrer. Exercice 4: Le train

Chaque voiture sera un thread diff´ erent, qui, une fois pass´ ee sur le pont, recommence toujours dans la mˆ eme direction2. Modifiez votre solution pour permettre au plus 4

Dans ce Tp on impl´ ementera quelques algorithmes d’exclusion mutuelle sans utiliser les prim- itives de haut niveau comme les m´ ethodes synchronized ou les variables de

Le serveur stocke alors cette chaˆıne de caract` eres dans un objet de type ConcurrentBuffer Un client consommateur attend que le serveur lui envoie des chaˆınes de caract` eres qui

Le premier argument est l’adresse d’un descripteur de thread, le deuxi`eme argument (que nous mettrons toujours ` a NULL dans ces TP) est un attribut de thread de type pthread_attr_t

Dans cet exercice on souhaite mod´eliser ce probl`eme du dˆıner des philosophes par un programme en C dans leque chaque baguette sera repr´esent´ee par un verrou et chaque

L`a aussi il est recommand´ e d’appeler cette fonction au sein d’une section critique prot´eg´ee par le mutex utilis´e par le thread en attente (dans l’exemple pr´ec´edent

La premi`ere n’autorisera pas un consommateur ` a lire une nouvelle donn´ee tant que la derni`ere donn´ee lue n’aura pas ´et´e vue par tous les consommateurs (le dernier