Sorbonne Université Master 2017 2018
PR : Travaux sur Machine 6. Introduction à la communication inter-processus (IPC)

Cette première séance consacrée aux segments de mémoire partagée et aux files de messages évite les accès concurrents à ces nouvelles ressources afin d’en maîtriser l’écriture de base. Les premiers exercices sont des réécritures avec ces outils de celui des remontées de valeurs de la séance Fichiers et Processus, sans écrire dans un fichier.

Les deux derniers exercices sont des variantes où ce n’est plus le processus principal mais les processus fils qui effectuent des sommes de valeurs aléatoires, en utilisant des files de messages.

Remarque 1 : Selon les plates-formes, vous aurez peut-être besoin de donner à LDFLAGS la valeur -lrt dans le Makefile pour que l’édition de liens réussisse.

Remarque 2 : les files de messages et les segments de mémoire partagée créés à chaque exécution doivent impérativement être détruits en fin de programme sinon des comportements incohérents s’ensuivront, liés à des variables dont les valeurs sont restées en mémoire après la terminaison du programme précédent. Pour vérifier ce qu’il en est, utilisez la commande ipcs et ses congénères cités dans le manuel.

On peut également nettoyer files de messages et segments partagés en effaçant les "fichiers" dans : /dev/mqueue et /dev/shm respectivement.



1 Remontée par partage de mémoire

Ecrire en C un programme prenant en argument un nombre n. Il créé avec mmap un segment de mémoire partagée de n entiers, puis crée n processus fils, à l’aide de fork. Chaque processus fils i produit une valeur aléatoire qu’il insère dans la case i du segment. De son côté, le processus principal doit attendre la terminaison de tous ses fils, puis extraire toutes les valeurs du segment pour ensuite les additionner et enfin afficher la somme résultante. Pour finir, le processus libère le segment en utilisant munmap.

Deux alternatives sont possibles pour réaliser cet exercice ;

Exemple d'appel :
$PWD/bin/remonte_posix_partagee 4
Fichier à créer : src/remonte_posix_partagee.c

2 Remontée par file de messages

Adaptez l’exercice précédent cette fois à l’utilisation d’une file de messages pour envoyer chaque valeur aléatoire. Vous utiliserez les fonctions C mentionnées dans le cours, dont la documentation est indirectement accessible via le panorama mq_overview donné par le manuel Unix.

Exemple d'appel :
$PWD/bin/remonte_ipc 4
Fichier à créer : src/remonte_ipc.c

3 Serveur de valeurs aléatoires à files multiples

On souhaite à présent que chaque processus soit associé à une file de messages MQi, où i est le numéro d’ordre de création du processus fils : 0 < i < N-1. Le programme principal est associé à la file MQN. Il y a donc en tout N+1 files de messages.

Cette fois-ci la valeur aléatoire générée par chaque processus fils, notée max_msg_i (1 <= max_msg_i <= N), représente le nombre de messages que le processus fils veut recevoir de son père. Une fois générée, chaque fils envoie cette valeur à son père par le biais de la file de messages associée au processus principal. Chaque processus fils attend ensuite sur sa propre file de messages que son père lui renvoie max_msg_i messages.

Dans ces messages, le processus père insère à chaque fois une valeur tirée aléatoirement entre 0 et 100. Lorsque tous les messages ont été extraits de sa file, chaque processus fils fait la somme des valeurs reçues et affiche le résultat.

Exemple d'appel :
bin/multi_remonte 4
Fichier à créer : src/multi_remonte.c

4 Serveur de valeurs aléatoires à file unique

On reprend le problème précédent, en créant une seule file et n segments partagés SHi (taille = MAX, tel que 0 < n < MAX dans la suite) Chacun des n fils créés :

De son côté le processus principal fera n fois :

Enfin il attend ses n fils, libère les ressources, et se termine.

Exemple d'appel :
bin/multi_remonte_file_unique 4
Fichier à créer : src/multi_remonte_file_unique.c

5 Annexes


makefile