Séance de TP numéro 8 : Files de messages, Sémaphores et Mémoire Partagée

Files de messages.

L'intérêt majeur des files de messages, comparativement aux pipes, est que la communication peut s'effectuer dans les deux sens. Voici quelques fonctions usuelles.

Fonction "msgget"

#include < sys/msg.h >
int msgget(key_t cle, int option);

Cette fonction permet la création d"une nouvelle file de messages ou la recherche de l'identification d'une file existante à partir de sa clé. Un appel à cette fonction renvoie l'identification d'une file de messages ou -1 en cas d'erreur.
Primitive d'envoi "msgsnd"

#include < sys/ msg.h >
int msgsnd (int msgid, const void * p_msg, int lg, int option);

C'est par l'intermédiaire de cette primitive qu'un processus connaissant l'identification interne d'une file pourra y envoyer des messages.Un appel à cette fonction envoie dans la file d'identification msgid le message pointé par p_msg.
Primitive d'extraction "msgrcv"

#include < sys/msg.h >
int msgrcv (int msgid, void * p_msg, int taille, long type, int option);

Cette primitive permet à un processus, connaissant l'identification d'une file de messages d'extraire un message de celle-ci. Un appel à cette fonction est une demande de lecture das la file d'identification msgid.

Sémaphores.
Les sémaphores peuvent être utilisés pour fournir un accès exclusif à certaines ressources de la machine, ou pour limiter le nombre de processus qui utilisent en même temps une ressource. Les sémaphores permettent ainsi à plusieurs processus de se synchroniser.

Fonction "semget"

#include < sys/types.h >
#include < sys/ipc.h >
#include < sys/sem.h >

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

La fonction "semget" crée un ensemble de sémaphores. L'entier retourné est le semid de l'ensemble de sémaphores ou -1 en cas d'erreur. semflag spécifie les priorités d'accès à l'ensemble de sémaphores. nsems désigne le nombre de sémaphores présents dans l'ensemble.
Fonction "semctl"

#include < sys/types.h >
#include < sys/ipc.h >
#include < sys/sem.h >

union semun { int val; struct semid_ds *buf; ushort *array }

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

La fonction "semctl" permet de réaliser des opérations de contrôle sur l'ensemble de sémaphores identifié par semid. semnum désigne le numéro du sémaphore de l'ensemble concerné par l'opération, arg un (ou des) argument(s) variant suivant la commande. Le type d'opération est spécifié par cmd :
- GETVAL : renvoie la valeur de semval du sémaphore semnum.
- SETVAL : affecte la valeur arg.val à semnum.
- IPC_RMID : détruit les sémaphores de l'ensemble, semid et semid_ds.
Fonction "semop"

#include < sys/types.h >
#include < sys/ipc.h >
#include < sys/sem.h >

int semop(int semid, struct sembuf *sops, size_t nsops);

La fonction "semop" effectue une série d'opérations définies par les nsops éléments de sops, qui sont du type sembuf. Trois types d'opérations sont permis :
- sem_op < 0 (correspond au "P" : Proberen ou Puis-je ?)
  - Si (semval >= |sem_op|), alors semval = semval - |sem_op|.
  - Si (semval < |sem_op|), alors semncnt++ et le processus appelant est mis en attente jusqu'à ce que (semval >= |sem_op|). Ensuite, semncnt-- et semval=semval-|sem_op|.
- sem_op > 0 (correspond au "V" : Verhogen ou Vas-y !)
  - semval = semval + sem_op.
- sem_op = 0
  - Si (semval = 0), alors retour immédiat.
  - Si (semval != 0), alors semzcnt++ et le processus appelant est mis en attente jusqu'à ce que (semval=0). Ensuite, semznct--.

Mémoire partagée.
Le partage de mémoire entre plusieurs processus est le moyen le plus rapide d'échange de données. Pour pouvoir partager de la mémoire, on doit utiliser les primitives suivantes :

shmget construit le segment de mémoire partagée ;
shmctl permet d'intervenir sur ce segment ;
shmat permet à un processus de s'attacher ce segment ;
shmdt permet à un processus de se détacher du segment.

Exercice 1 : Files de messages

On souhaite ici mettre en place une communication entre un client et un serveur par le biais d'une file de messages. Le serveur effectue l'addition de deux nombres envoyés par un client et renvoie le résultat. La communication s'effectuant par l'intermédiaire d'une file de messages, cette file contient tout à la fois les requêtes en provenance des clients et les réponses du serveur.

Dans cette application, le serveur doit uniquement consommer les requêtes depuis la file de messages. Les clients, de leur côté, doivent uniquement lire la réponse qui les concerne.

Pour parvenir à ce schéma, on utilise le champ type dans la structure des messages véhiculés par la file de messages. Ainsi, le serveur désigne le client auquel s'adresse la réponse en remplissant le champ type de la réponse avec la valeur du pid du client. Ce pid est indiqué par le client au niveau de sa requête. Le client, quant à lui, désigne le serveur comme destinataire de la requête en initialisant le champ type de sa requête avec une valeur positive qui ne peut correspondre à un pid de processus utilisateur, par exemple la valeur 1 (cette valeur 1 correspond obligatoirement au processus init)
La requête et la réponse auront le format suivant :

struct requete {long letype; int nb1; int nb2; pid_t mon_pid; };
struct reponse {long letype; int res; };

Solution : Serveur et Client

Exercice 2 : Les six cuisinières et le quatre-quarts

Six cuisinières souhaitent confectionner un quatre-quarts, gâteau composé des quatres ingrédients suivants : oeufs, farine, beurre et sucre (en poudre). Chacune d'elles dispose d'une quantité illimitée de deux de ces ingrédients. La disposition des lieux fait qu'une seule personne à la fois peut confectionner son gâteau. Lorsqu'aucune cuisinière ne travaille, un agent extérieur dépose la quantité nécessaire de deux ingrédients permettant, ajoutés à une égale quantité des autres, la confection du gâteau. Les cuisinières étant bien élevées, aucune ne se saisira d'un seul ingrédient : seule celle ayant besoin des deux ingrédients déposés, s'en saisira. On se propose de décrire une simulation de cette situation au moyen d'un ensemble de cinq sémaphores (un associé à chaque ingrédient dont la valeur sera 1 quand il aura été déposé et un autre qui sera égal à 1 lorsque l'agent extérieur pourra déposer des ingrédients, c'est à dire quand aucune cuisinière ne sera en action).

Proposez une solution de ce problème en langage C.

Cuisinière1

Cuisinière2

Cuisinière3

Cuisinière4

Cuisinière5

Cuisinière6

Agent extérieur

Que se passe-t-il si le nombre de cuisinières est plus petit ? Plus grand ? Si le nombre de cuisinières est plus petit, tous les processus peuvent se retrouver bloquer (car il se peut qu'aucune des cuisinières ne soit interressée par les ingrédients après le passage de l'agent, et dans ce cas tout le monde attend). Si le nombre est plus grand, certaines des cuisinières ont exactement les mêmes ingrédients de départ, aussi lors du passage de l'agent, si les ingrédients les intéressent, elles seront appelées aléatoirement par le processeur (certaines peuvent donc être lésées, la répartition entre les processsus n'étant pas nécessairement équitable !)

Exercice 3 : Lecteurs-rédacteurs

Dans cet exercice, on considère la situation où une zone de mémoire partagée est accédée simultanément en lecture et en écriture. Il y a donc deux types de processus, d'une part des processus lecteurs et d'autre part des processus rédacteurs.

Deux objectifs doivent être atteints: le contenu de la zone de mémoire doit évidemment rester cohérent (donc les écritures ne doivent pas avoir lieu en même temps) et les lecteurs doivent lire une information stable (c'est-à-dire que les lecteurs ne doivent pas lire une information en cours de modification).

Programmez un schéma lecteur-rédacteur entre un processus père et son fils pour l'accès à une variable commune. Le processus père modifie la variable commune en la multipliant par 10. Le processus fils lit la valeur commune puis l'affiche.

Solution

Modifiez légèrement votre programme pour que celui-ci s'applique au cas d'un processus père rédacteur et de deux processus fils lecteurs. Voyez-vous quelque chose qui pourrait être amélioré ? Proposez une amélioration.
Solution et Solution améliorée

Bibliographie : Source d'exercices

On pourra se référer aux TPs analogues donnés en 2008 et 2009 par Damien Vergnaud .