Remarques préliminaires :

• Prendre connaissance des documents :
  Les I.P.C.s d'Unix System V
  Coopération entre les processus
• Créer le répertoire tpsys/dirpartagersc, qui sera considéré comme répertoire courant, jusqu'à une nouvelle indication.
• Comme précédemment, ne testez pas avant que cela vous soit explicitement demandé dans l'énoncé,
• Pensez à consulter les objectifs pédagogiques

Sommaire

Classe d'exceptions spécifique aux IPCs
Classe COperation
Wrappers
Wrappers de l'I.P.C. "Ensemble de sémaphores"

Fonction semget()
Fonction semctl()
Fonctions spécifiques aux sémaphores : semop()

Classe CSemBase

Modifications de MakeUtil
Modifications de Makefile

Section critique	exo_01
Primitive P() non bloquante	exo_02
Simulation du contrôle d'accès à une piscine	exo_03
Simulation du problème des cinq philosophes	exo_04

Outils nécessaires à la coopération entre processus

Classe d'exceptions spécifique aux IPCs

    Toutes les fonctions système qui manipulent les I.P.C.s (Inter Process Communication) ont pour premier paramètre un identificateur d'IPC :

• de sémaphore            (semid),
• de mémoire partagée (shmid),
• de file de message     (msqid) (q comme queue).

    Dans les fichiers CExcFctSyst.h et CExcFctSyst.hxx dériver la nouvelle classe CExcFctSystIPC de CExcFctSyst, analogue à CExcFctSystFile, en remplaçant le nom de fichier et le file descriptor par la clé de l'I.P.C. (m_key) et son identificateur (m_id).

Rq1

Corrigé : CExcFctSyst.h    -    CExcFctSyst.hxx

 Sommaire

Classe COperation

• le rang du sémaphore, dans l'ensemble des sémaphores, auquel elle doit être appliquée,
• la valeur numérique correspondant à la nature de l'opération à effectuer,
• un flag ajoutant une option à l'opération

Wrappers

    Cela conduit à écrire plus de 20 wrappers différents pour seulement quelques fonctions système de base, travail indispensable pour faciliter une programmation ultérieure sécurisée, mais gros consommanteur de temps. Nous supposons que le principe d'écriture en C++ de plusieurs wrappers d'une même fonction système est maintenant connu, les corrigés vous sont donc fournis. Cependant, pour pouvoir les utiliser correctement par la suite, vous devez en prendre connaissance de façon attentive avant de les intégrer dans les fichiers nsSysteme.h,  nsSysteme.hxx et nsSysteme.cxx. C'est pourquoi nous vous recommandons de suivre la procédure ci-dessous et de ne pas récupérer directement les versions finales des corrigés des fichiers nsSysteme.h et nsSysteme.hxx, accessibles ci-dessous.

    Bien que les fonctions système de la même famille (par exemple xxxget()) aient des profils très semblables, nous ne développerons pas leurs wrappers simultanément. Au contraire, nous introduirons ceux-ci au fur et à mesure de la nécessité de chaque type d' I.P.C.s. Ainsi, les wrappers s'appliquant aux familles de sémaphores seront développées dans ce TP ("Partage de ressources"), ceux qui concernent les files de messages seront introduits dans le TP consacré à l'implémentation du modèle "Producteurs/Consommateurs", ceux qui concernent les mémoires partagées seront introduits dans le TP consacré à l'implémentation du modèle "Lecteurs/Rédacteurs". Dans ces différents TPs seront introduits des wrappers d'autres fonctions système lorsqu'elles devront être utilisées.

Wrappers de l'I.P.C. "Ensemble de sémaphores"

Fonction semget()

• l'un pour créer la ressource (même profil que la fonction système),
• l'autre pour utiliser la ressource lorsqu'elle existe déjà : le seul paramètre nécessaire est la clé.

    A ajouter au fichier nsSysteme.h :
 

// Fonctions concernant les ensembles de sémaphores     // ================================================     int  Semget (::key_t key, int nsems, int semflg)                       throw (CExcFctSystIPC);     int  Semget (::key_t key)                       throw (nsUtil::CExcFct);

    A ajouter au fichier nsSysteme.hxx (Rq2) :
 

//================================================= // Fonctions concernant les ensembles de sémaphores //================================================= inline int nsSysteme::Semget (::key_t key, int nsems, int semflg)     throw (CExcFctSystIPC) {     int SemId;     if (-1 == (SemId = ::semget (key, nsems, semflg)))         throw CExcFctSystIPC ("semget() : pour création de sem", key, -1);     return SemId; } // Semget()

    A ajouter au fichier nsSysteme.cxx :
 

//================================================= // Fonctions concernant les ensembles de sémaphores //================================================= int nsSysteme::Semget (::key_t key) throw (CExcFct) {     if (IPC_PRIVATE == key)         throw CExcFct ("semget() : clé IPC_PRIVATE sans droits",                        CstSemgetErrArg);     int SemId;     if (-1 == (SemId = ::semget (key, 0, 0)))         throw CExcFctSystIPC ("semget() : pour sem existant", key, -1);     return SemId; } // Semget()

    La constante CstSemgetErrArg = 133 doit être ajoutée au fichier CstCodErr.h.

Fonction semctl()

• lorsqu'elle est utilisée pour détruire un ensemble de sémaphores, son paramètre cmd doit avoir pour valeur IPC_RMID. Les autres paramètres, semnum et arg,  ne sont pas utilisés mais doivent être présents. En fait, seul le paramètre semid est utile. Le wrapper utilisé pour détruire un ensemble de sémaphores aura donc pour profil :

 

void Semctl (int semid) throw (CExcFctSystIPC);

 
• lorsqu'elle est utilisée avec l'une des valeurs GETVAL, GETPID, GETNCNT ou GETZCNT comme commande cmd, la valeur du paramètre arg n'est pas utilisée, donc le profil du wrapper doit être le suivant :

 

int Semctl (int semid, int semnum, int cmd) throw (nsUtil::CExcFct);


La fonction lève une exception CExcFct si le paramètre cmd n'a aucune des valeurs indiquées.
 
• lorsqu'elle est utilisée avec la valeur SETVAL comme commande cmd, le profil du wrapper doit être le suivant :

 

void Semctl (int semid, int semnum, int cmd, int val) throw (nsUtil::CExcFct);


La fonction lève une exception CExcFct si le paramètre cmd n'a pas la valeur SETVAL.
 
• lorsqu'elle est utilisée avec l'une des valeurs IPC_STAT ou IPC_SET comme commande cmd, le profil du wrapper doit être le suivant :

 

void Semctl (int semid, int cmd, ::semid_ds * buf) throw (nsUtil::CExcFct);


La fonction lève une exception CExcFct si le paramètre cmd n'a pas l'une des deux valeurs indiquées.
 
• lorsqu'elle est utilisée avec l'une des valeurs GETALL ou SETALL comme commande cmd, le profil du wrapper doit être le suivant :

 

void Semctl (int semid, int cmd, unsigned short array []) throw (nsUtil::CExcFct);


La fonction lève une exception CExcFct si le paramètre cmd n'a pas l'une des deux valeurs indiquées.

    A ajouter au fichier nsSysteme.h :
 

// uniquement pour détruire l'ensemble de sémaphores     void Semctl (int semid)                       throw (CExcFctSystIPC);     // si cmd == GETVAL ou GETPID ou GETNCNT ou GETZCNT :     int   Semctl (int semid, int semnum, int cmd)                       throw (nsUtil::CExcFct);     // si cmd == SETVAL :     void Semctl (int semid, int semnum, int cmd, int val)                       throw (nsUtil::CExcFct);     // si cmd == IPC_STAT ou IPC_SET :     void Semctl (int semid, int cmd, ::semid_ds * buf)                       throw (nsUtil::CExcFct);     // si cmd == GETALL ou SETALL     void Semctl (int semid, int cmd, unsigned short array [])                       throw (nsUtil::CExcFct);

    A ajouter au fichier nsSysteme.hxx (Rq3) :
 

#if defined (__GNU_LIBRARY__) && !defined (_SEM_SEMUN_UNDEFINED)     /* union is defined by including <sys/sem.h> */ #else     /* according to X/OPEN we have to define it ourselves */     union semun     {         int val;                       //    <= value for SETVAL         struct ::semid_ds *buf;        //    <= buffer for IPC_STAT & IPC_SET         unsigned short int *array;     //    <= array for GETALL & SETALL         struct ::seminfo *__buf;       //    <= buffer for IPC_INFO     }; // semun #endif     __GNU_LIBRARY__ & !_SEM_SEMUN_UNDEFINED #define semun semun // uniquement pour détruire l'ensemble de sémaphores inline void nsSysteme::Semctl (int semid) throw (CExcFctSystIPC) {     ::semun Union;     if (::semctl (semid, 0, IPC_RMID, Union))         throw CExcFctSystIPC ("semctl() : destruction", -1, semid); } // Semctl()

    A ajouter au fichier nsSysteme.cxx :
 

#ifndef semun #if defined (__GNU_LIBRARY__) && !defined (_SEM_SEMUN_UNDEFINED)     /* union is defined by including <sys/sem.h> */ #else     /* according to X/OPEN we have to define it ourselves */     union semun     {         int val;                       //    <= value for SETVAL         struct ::semid_ds *buf;        //    <= buffer for IPC_STAT & IPC_SET         unsigned short int *array;     //    <= array for GETALL & SETALL         struct ::seminfo *__buf;       //    <= buffer for IPC_INFO     }; // semun #endif     __GNU_LIBRARY__ & !_SEM_SEMUN_UNDEFINED #endif     semun // si cmd == GETVAL ou GETPID ou GETNCNT ou GETZCNT : int nsSysteme::Semctl (int semid, int semnum, int cmd) throw (nsUtil::CExcFct) {     if ((GETVAL != cmd) && (GETPID != cmd) && (GETNCNT != cmd) &&         (GETZCNT != cmd))         throw CExcFct ("semctl() : GETxxx", CstSemctlErrArg);     int Val;     ::semun Union;     if (-1 == (Val = ::semctl (semid, semnum, cmd, Union)))         throw CExcFctSystIPC ("semctl() : GETxxx", -1, semid);     return Val; } // Semctl() // si cmd == SETVAL : void nsSysteme::Semctl (int semid, int semnum, int cmd, int val)     throw (nsUtil::CExcFct) {     if (SETVAL != cmd) throw CExcFct ("semctl() : SETVAL", CstSemctlErrArg);     ::semun Union;     Union.val = val;     if (::semctl (semid, semnum, cmd, Union))         throw CExcFctSystIPC ("semctl() : SETVAL", -1, semid); } // Semctl() // si cmd == IPC_STAT ou IPC_SET : void nsSysteme::Semctl (int semid, int cmd, ::semid_ds * buf)     throw (nsUtil::CExcFct) {     if ((IPC_STAT != cmd) && (IPC_SET != cmd))         throw CExcFct ("semctl() : IPC_xxx", CstSemctlErrArg);     ::semun Union;     Union.buf = buf;     if (::semctl (semid, 0, cmd, Union))         throw CExcFctSystIPC ("semctl() : IPC_xxx", -1, semid); } // Semctl() // si cmd == GETALL ou SETALL void nsSysteme::Semctl (int semid, int cmd, unsigned short array [])     throw (nsUtil::CExcFct) {     if ((SETALL != cmd) && (GETALL != cmd))         throw CExcFct ("semctl() : xxxALL", CstSemctlErrArg);     ::semun Union;     Union.array = array;     if (::semctl (semid, 0, cmd, Union))         throw CExcFctSystIPC ("semctl() : xxxALL", -1, semid); } // Semctl()

Fonctions spécifiques

    A ajouter au fichier nsSysteme.h :
 

void Semop  (int semid, ::sembuf * sops, unsigned int nsops)                       throw (CExcFctSystIPC);

    A ajouter au fichier nsSysteme.hxx :
 

inline void nsSysteme::Semop  (int semid, ::sembuf * sops,                                unsigned int nsops) throw (CExcFctSystIPC) {     if (::semop (semid, sops, nsops))         throw CExcFctSystIPC ("semop()", -1, semid); } // Semop()

Corrigé : nsSysteme.h    -    nsSysteme.hxx    -    nsSysteme.cxx    -    CstCodErr.h

 Sommaire

Classe CSemBase

    A partir du répertoire des corrigés tppartagersc/include, recopier dans votre répertoire correspondant le fichier CSemBase.h. Il contient la déclaration d'une classe CSemBase, de l'espace de noms nsSysteme, permettant de créer un sémaphore n-aire (par défaut binaire). La donnée membre m_Proprietaire contient le pid du processus qui a créé le sémaphore par la fonction Semget() et qui est le seul habilité à le détruire par Semctl()). La donnée membre m_id contient l'identificateur de sémaphore renvoyé par Semget().

    Ecrire dans le fichier CSemBase.hxx le corps des fonctions membres de la classe.

    Modifier le fichier INCLUDE_H pour prendre en compte les fichiers inclus COperation.h, COperation.hxx, CSemBase.h, CSemBase.hxx. En profiter pour supprmier la macro COMPILER (explications plus loin).

Corrigé : INCLUDE_H    -    CSemBase.hxx

 Sommaire

Bibliothèque de fichiers objets

ainsi que la liste des fichiers .o à raffraîchir :
 

cible :          cd $(UTIL); make -f MakeUtil nsSysteme.o main.o nsUtil.o      \                                       CException.o    SaveSig.o        \                                       TestFdOuverts.o Autopsie.o

    De plus, il devient facile de commettre des erreurs.

    Une bonne solution est de constituer une bibliothèque (library) de fichiers objets (.o), mise à jour à chaque recompilation, et d'indiquer au compilateur g++ d'aller chercher dedans les fichiers dont il peut avoir besoin. Cela implique la modification des fichiers MakeUtil et Makefile. Une bibliothèque doit commener par le préfixe lib, nous l'appellerons donc libSys.

Modifications de MakeUtil

    De plus le nettoyage des fichiers compilés doit être modifié :
 

# # Nettoyage du répertoire courant : bibliothèque et fichiers .o # clean :         clear; rm -f *.o *.a -v

    Enfin, pour éviter de relancer toutes les compilations en énumérant chaque cible, il est préférable de les regrouper en une seule, placée en début de fichier :
 

general : nsUtil.o         CException.o   nsSysteme.o   main.o       \          TimeBase.o        Time.o         CTimer.o      SaveSig.o    \          TestFdOuverts.o   Autopsie.o

    Noter qu'il n'y a pas de commande associée. Modifications de Makefile     Recopier le fichier ../dirprocess/Makefile dans le répertoire de travail (dirpartagersc).

    Puisque la macro COMPILER a été supprimée du fichier INCLUDE_H, il est nécessaire de la réintroduire dans le fichier Makefile :
 

COMPILER = g++ -I$(INCLUDE) -c $*.cxx -Wall

    Dans l'exemple ci-dessous, nous supposons que le programme ne dépend pas de fichiers objets .o dans le répertoire courant.

    Pour l'édition de liens, il faut indiquer au compilateur g++, au moyen de l'option -L (assez semblable à l'option -I) qu'il doit aller chercher les références dans le répertoire util (-L$(UTIL)), dans la bibliothèque libSys, par l'option -l (-lSys).
 

$(nom) : cible $(nom).o         g++ -s -o $(nom) $(nom).o                                      \                   -L$(UTIL) -lSys

    Noter la suppression du préfixe lib.

    Il ne reste plus qu'à mettre à jour la cible :
 

cible :         cd $(UTIL); make -f MakeUtil

 Sommaire

Partage de ressources

Section critique

exo_01

• Section critique réalisée avec un mutex
• Liste des fichiers : exo_01.cxx, Makefile

    Modifier le fichier Makefile, compiler et tester.

    Vous constatez que le programme ne fonctionne pas correctement. En effet, l'algorithme donne le droit de détruire l'ensemble de sémaphores seulement à son processus propriétaire (celui qui l'a créé). Il faut en réalité que ce soit le dernier processus à l'utiliser qui ait ce droit. Malheureusement, il est impossible de le connaître. Une solution simple, dans ce problème, consiste à obliger le processus créateur à être le dernier à se terminer : il suffit qu'il attende la mort de son fils.

    Faire la modification, compiler et tester.

    Cette fois, vous devez constater que deux seules séquences sont possibles : le père s'exécute complètement avant le fils, ou l'inverse. Cette solution est souvent utilisée, et le père peut être réduit à créer des ressources, puis lancer tous les processus qui doivent coopérer, et enfin attendre la fin de tous ces processus pour libérer les ressources (ici par simple appel au destructeur).

Corrigé : Makefile    -    exo_01.cxx

Remarque : que pensez-vous de la solution suivante ?
 

char c;     const int fd = Open ("exo_01.txt", O_RDWR);     if (Fork ())                                        /* 01 */     {         CMutex Mutex (atoi (argv [1]));         Mutex.P();         Lseek (fd, 10, SEEK_SET);                       /* 02 */         Read  (fd, &c, 1);                              /* 03 */         cout << "lu par le pere : " << c << endl;       /* 04 */         Read  (fd, &c, 1);                              /* 05 */         cout << "lu par le pere : " << c << endl;       /* 06 */         Mutex.V();         Wait ();     }     else     {         CMutex Mutex (atoi (argv [1]));         Mutex.P();         Lseek (fd, 3, SEEK_SET);                        /* 07 */         Write (fd, "ABCDE", 3);                         /* 09 */         cout << "lu par le fils : " << c << endl;       /* 10 */         Mutex.V();     }

    Vous pouvez l'essayer, il s'agit du fichier exo_01b.cxx dans le répertoire des corrigés dirpartagersc

Corrigé

 Sommaire

Primitive P() non bloquante

exo_02

• Liste des fichiers créés ou modifiés : exo_02d.cxx, exo_02.cxx, CSemaphore.h, CSemaphore.hxx, CSemaphore.cxx, INCLUDE_H, Makefile, MakeUtil, ScriptEcran,

• soit en utilisant la fonction select() avec un timer, et qui est bloquante jusqu'à  l'occurrence de l'événement ou jusqu'à épuisement du délai (timeout)
• soit en armant un timer (ou en appelant alarm()) après avoir détourné SIGALRM, puis en effectuant un autre traitement (ou une pause())

    Plusieurs processus nécessitent l'écran pour leurs affichages mais, afin de ne pas mélanger les éditions, son utilisation est mise en exclusion mutuelle au moyen d'un sémaphore binaire. Si après plusieurs tentatives infructueuses, séparées d'un délai d'attente variable, un processus ne peut accéder à l'écran, il finit par se décider à rediriger ses éditions sur un fichier. Pour réaliser cet algorithme, il faut modifier la primitive P(). En effet, cette dernière est bloquante et le processus ne peut pas "l'essayer" pour voir s'il peut accéder à la ressource. Il faut donc enrichir la classe CSemBase.

    Dans les fichiers include/CSemaphore.h, include/CSemaphore.hxx et util/CSemaphore.cxx, dériver la classe CSemBase en CSemaphore. Lui ajouter la fonction membre :
 

bool P_WouldBlock (void);

qui ne bloque jamais le processus mais qui renvoie vrai chaque fois que le processus aurait dû être bloqué (utiliser le flag IPC_NOWAIT de la fonction semop()).

    Modifier les fichiers INCLUDE_H, Makefile et MakeUtil.

    Pour créer et détruire les ressources (un ensemble de sémaphores) nous utiliserons ici une nouvelle technique : dans le fichier exo_02d.cxx, écrire un programme qui :

• se transforme en démon,
• crée un CSemaphore binaire à partir de la clé qui lui est passée en argument,
• affiche son pid,
• se protège de tous les signaux sauf SIGUSR1 qu'il détourne,
• attend dans une instruction pause().
• à réception du signal SIGUSR1, se termine après avoir détruit l'ensemble de sémaphores.

    Dans le fichier exo_02.cxx, écrire un programme qui, à intervalles réguliers, essaie de s'accaparer l'écran en bloquant le sémaphore créé par exo_02d (utilisation de P_WouldBlock()). S'il y arrive, il affiche un certain nombre de fois son numéro de pid (une fois/seconde) puis libère l'écran. S'il n'y arrive pas, il effectue la même opération sur un fichier de secours. Les paramètres de la commande exo_02 sont :

• la clé de l'ensemble de sémaphores,
• le délai entre chaque tentative d'acquisition de l'écran,
• le nombre maximal de tentatives,
• le nombre d'éditions consécutives du pid,
• le nom du fichier de secours

Corrigés : exo_02d.cxx    -    exo_02.cxx    -    CSemaphore.h    -    CSemaphore.hxx    -    CSemaphore.cxx    -    INCLUDE_H    -    Makefile    -    MakeUtil    -    ScriptEcran

 Sommaire

Simulation du contrôle d'accès à une piscine

exo_03

• Liste des fichiers créés ou modifiés : Baigneur.cxx, exo_03d.cxx, ScriptPiscine, Reveil.h, Reveil.cxx, Makefile, MakeUtil, INCLUDE_H, nsPiscine.h, nsPiscine.cxx

    Il est fastidieux de retrouver le pid du démon qui doit détruire les ressources lorsque tous les processus utilisateurs sont terminés, et de lui envoyer un signal particulier (passé en paramètre). Pour simplifier cette tâche, le démon génèrera un script, de nom prédéfini (ou passé en paramètre), qui effectuera ces opérations.

    Dans les fichiers Reveil.h et Reveil.cxx des répertoires include et util, déclarer et définir la fonction de profil :
 

void nsUtil::Reveil (int NumSig                    = SIGKILL,                      const std::string & NomScript = "Reveil")     throw (nsSysteme::CExcFctSystFile);

    La fonction doit générer un script (fichier exécutable) d'identificateur NomScript contenant :

• la commande kill qui doit envoyer au processus courant (c'est le démon lui-même qui appelle la fonction Reveil() dont le script généré est chargé de le réveiller) le signal NumSig
• la commande qui efface le script après son exécution

• deux sortes de comportement doivent être simulés :
• le responsable de la piscine qui
• ouvre la piscine. Cette action consiste ici à mettre à disposition des baigneurs les ressources de la piscine : des "paniers" pour stocker les habits et des cabines pour se changer. Le nombre de paniers est au moins égal au nombre de cabines.
• attend "qu'on" lui dise de fermer la piscine
• ferme la piscine.
• les baigneurs qui
• se présentent tous en même temps à l'entrée de la piscine,
• demandent un panier et une cabine  pour se déshabiller
• se déshabillent
• libèrent la cabine
• se baignent
• demandent une cabine pour se rhabiller
• se rhabillent
• quittent la piscine
• tout en étant assez réaliste, cette simulation n'a pas la prétention de modéliser parfaitement le phénomène. Plusieurs points devraient en effet être améliorés, mais ils ne font pas partie de l'énoncé. En particulier :
• il est impensable que le responsable ferme la piscine avant que tous les baigneurs soient partis,
• l'événement qui provoque la fermeture de la piscine devrait être une alarme déclenchée par un sablier,
• on pourrait imaginer une période pendant laquelle les baigneurs ne pourraient plus entrer, mais pourraient encore sortir,
• il faudrait que le responsable ait des "moyens de pression" pour "inciter" les baigneurs à quitter la piscine, même s'ils en avaient décidé autrement !
• l'arrivée des baigneurs à l'entrée de la piscine devrait être étalée dans le temps.
• la demande de la cabine et du panier pourrait être dissociée : d'abord le panier, puis la cabine (et surtout pas le contraire, sous peine d'interblocage !)
• l'implémentation souhaitée met en oeuvre deux sortes de fonctions : les fonctions de synchronisation (tableau 1), et les fonctions modélisant les autres actions des protagonistes, qui seront remplacées par des attentes limitées : sleep() ou indéfinies : pause().
• le responsable de la piscine est un processus, lancé à la main par l'utilisateur, qui :
• réserve et initialise correctement les ressources (sémaphores) dont il connaît la clé. Compte tenu de l'énoncé, il s'agit d'un ensemble de deux sémaphores (le baigneur demande un panier et une cabine simultanément) : fonction OuvrirPiscine()
• se transforme en démon
• attend que les processus utilisateurs de ces ressources soient terminés. Cette attente doit être passive (pas d'attente active), au moyen de la fonction pause(), et se termine à réception du signal SIGUSR1, envoyé par l'utilisateur.
• libère les ressources  : fonction FermerPiscine()
• chaque baigneur est un processus qui :
• entre dans la piscine (ce qui se traduit par l'acquisition de l'identificateur de l'ensemble de sémaphores dont il connaît la clé) : fonction ArriverPiscine()
• demande un panier et une cabine : fonction DebutDeshabiller()
• se déshabille : fonction sleep()
• rend la cabine : fonction FinDeshabiller()
• se baigne  : fonction  sleep()
• demande une cabine  : fonction DebutRhabiller()
• se rhabille : fonction  sleep()
• rend panier et cabine : fonction FinRhabiller()
• quitte la piscine : fonction PartirPiscine()
 

void OuvrirPiscine    (key_t Cle,                         const int NbrePaniers = 1,                         const int NbreCabines = 1) throw (CExcFctSystIPC); void FermerPiscine    (void)                      throw (CExcFctSystIPC); void ArriverPiscine   (key_t Cle)                 throw (CExcFctSystIPC); void PartirPiscine    (void)                      throw (CExcFctSystIPC); void DebutDeshabiller (void)                      throw (CExcFctSystIPC); void FinDeshabiller   (void)                      throw (CExcFctSystIPC); void DebutRhabiller   (void)                      throw (CExcFctSystIPC); void FinRhabiller     (void)                      throw (CExcFctSystIPC);

                                               Tableau 1 : fonctions de synchronisation
 

• les baigneurs sont lancés simultanément par l'utilisateur au moyen d'un script ScriptPiscine.
 
• tous les processus doivent donner la même signification à chacun des deux sémaphores de l'ensemble : lequel représente le nombre de paniers, lequel représente le nombre de cabines. Afin de faciliter le développement, ces informations seront regroupées dans un fichier, de même que toutes les fonctions de synchronisation.

    Dans le fichiers nsPiscine.cxx correspondant, étendre l'espace de noms nsPiscine pour lui ajouter :

• l'identificateur SemId de l'ensemble, nécessaire à toutes les fonctions de synchronisation,
• un type énumératif représentant la signification de chacun des sémaphores de l'ensemble.

    Ajouter au fichier les corps des différentes fonctions de synchronisation.

    Recopier le fichier exo_02d.cxx dans exo_03d.cxx. En utilisant les fonctions écrites ci-dessus, modifier le démon pour qu'il réalise les opérations suivantes :

• appeler Reveil(), (en remplacement de l'affichage de son pid),
• ouvrir la piscine,
• attendre dans une instruction pause() l'occurrence du signal SIGUSR1,
• fermer la piscine,
• se terminer.

• la clé de l'ensemble de sémaphores,
• le nom du baigneur,
• la durée de déshabillage,
• la durée du bain,
• la durée du rhabillage.

    Recopier le fichier Chrono.cxx de votre répertoire dirprocess ou du répertoire tppartagersc des corrigés. Le compiler.

    Compiler, écrire le script ScriptPiscine pour lancer simultanément plusieurs baigneurs et le programme Chrono en tâche de fond, qui permettra de reconstituer le chronogramme. Tester.

Corrigé : Baigneur.cxx    -    exo_03d.cxx    -    ScriptPiscine    -    Reveil.h    -    Reveil.cxx    -    Makefile    -    MakeUtil    -    INCLUDE_H    -    nsPiscine.h    -    Chrono.cxx    -    nsPiscine.cxx

 Sommaire

Simulation du problème des cinq philosophes (facultatif)

exo_04
 
• Liste des fichiers créés ou modifiés : nsPhilosophe.h, nsPhilosophe.cxx, Philosophe.cxx, Makefile, ScriptPhilosophe, exo_04d.cxx

    Recopier le fichier exo_03d.cxx dans exo_04d.cxx. Modifier le démon pour qu'il crée les ressources nécessaires.

    Dans le fichier Philosophe.cxx, écrire un programme qui simule le comportement d'un philosophe. Les arguments des commandes Philosophe sont :

• la clé de l'ensemble de sémaphores,
• le numéro du philosophe (entre 0 et 4),
• le nombre de cycles "penser-manger",
• la durée de "penser",
• la durée de "manger".

    Comme précédemment, on peut proposer un ensemble de fonctions, regroupées dans un espace de noms nsPhilosophe (fichiers nsPhilosophe.h et nsPhilosophe.cxx) permettant de modéliser le comportement des philosophes :
 

void DresserLaTable     (key_t Cle)   throw (nsSysteme::CExcFctSystIPC); void DebarrasserLaTable (void)        throw (nsSysteme::CExcFctSystIPC); void ArriverATable      (key_t Cle)   throw (nsSysteme::CExcFctSystIPC); void DebutManger        (const int i) throw (nsSysteme::CExcFctSystIPC); void FinManger          (const int i) throw (nsSysteme::CExcFctSystIPC); void QuitterLaTable     (void)        throw (nsSysteme::CExcFctSystIPC);

    Compléter le fichier Makefile pour qu'il puisse compiler les fichiers nsPhilosophe.cxx, exo_04d.cxx et Philosophe.cxx. Il est inutile de modifier le fichier INCLUDE_H.

    Compiler et tester au moyen d'un script qui lance le programme Chrono en tâche de fond, puis les cinq philosophes.

Corrigé : nsPhilosophe.h    -    nsPhilosophe.cxx    -    Philosophe.cxx    -    ScriptPhilosophe    -    Makefile    -    exo_04d.cxx

 Sommaire

Téléchargement des corrigés :

Chemins d'accès aux sources des corrigés :

[1] Rappel : un script est un fichier texte qui doit être exécutable par le c-shell. Pour cela il doit :

• commencer par le caractère #
• avoir les droits en exécution (x). Si vous ne trouvez aucun autre moyen, vous pouvez utiliser les fonctions système chmod() ou fchmod(), dont vous aurez préalablement écrit les wrappers.

© D. Mathieu    mathieu@romarin.univ-aix.fr
I.U.T.d'Aix en Provence - Département Informatique