La mémoire partagée (communication interprocessus : suite)

Définition

Les segments de mémoire partagée permettent aux processus de partager de l’information,

directement et sans contrôle. Il s’agît d’allouer une zone de la mémoire centrale qui sera
accessible directement par les processus connaissant la clé de cette zone, au travers d’un
pointeur. Il y a simplement quatre primitives fondamentales :

# include <sys / shm . h>

int shmget ( key_t cle , size_ t taille , int flag );

void ∗ shmat ( int identificateur , NULL, int option ) ;

int shmdt ( const void ∗ adresse ) ;

int shmctl ( int identificateur , int operation , NULL) ;

1. shmget(cle, taille, flag) retourne l’identificateur d’un segment à partir de sa clé (cle) ou -1 en cas
d’échec. Le segment sera créé s’il n’existait pas encore. On peut utiliser la clé IPC_PRIVATE pour la
création quand il n’est pas utile d’acquérir la clé (communication entre des processus parents). Le
paramètre taille donne le nombre d’octets du segment (s’il a déjà été créé, la taille doit être
inférieure ou égale à la taille de création). Le paramètre option est une combinaison (par OU bit à bit)
de constantes (telles que IPC_CREAT pour la création) et de droits d’accès (comme 0666). Par
exemple pour créer un segment on utilisera typiquement l’option IPC_CREAT|0666, et pour
l’acquisition simplement 0666.

2. shmat(identificateur, NULL, option) sert à attacher un segment, c’est à dire à obtenir une fois que
l’on connaît son identificateur, un pointeur vers la zone de mémoire partagée. L’option sera
SHM_RDONLY pour un segment en lecture seule ou 0 pour un segment en lecture/écriture. Cette
primitive retourne l’adresse de la zone de mémoire partagée ou (void *), (-1) en cas d’échec.

3. shmdt(adresse) sert à détacher le segment attaché à l’adresse passée en paramètre. Retourne 0

en cas de succès, ou -1 en cas d’échec.

4. shmctl (identificateur,operation,NULL) sert au contrôle (par exemple la suppression) du segment

dont l’identificateur est identificateur. Pour supprimer le segment, la valeur du paramètre operation
est IPC_RMID (la suppression ne sera effective que lorsque plus aucun processus n’attachera le
segment). Retourne 0 en cas de succès, ou -1 en cas d’échec.
Exemple

/* Exemple tiré de "Programmation avancée sous Linux"

* auteurs : Mark Mitchell, Jeffrey Oldham, Alex Samuel

* traduction : Sébastien Le Ray * site web :

http://www.advancedlinuxprogramming-fr.org/doku.php */

#include <iostream.h>

#include <sys/ipc.h>

#include <sys/types.h>

#include < sys/shm.h>

#include < sys/stat.h>

#include <cstream.h>

#include <unistd.h>

using namespace std ;

const int seg_size = 0x6400 ;

int main() {

char* shared_memory;

struct shmid_ds shmbuffer; int segment_size;

int id = shmget(IPC_PRIVATE, seg_size, IPC_CREAT | IPC_EXCL |

S_IRUSR | S_IWUSR);

/* Attache le segment de mémoire partagée. On cast en char * le

pointeur sur la fonction * ce qui permet à « shared_memory » de
pointer sur une chaîne de caractères */

shared_memory = (char*) shmat (id, 0, 0);

cout << "mémoire partagée attachée à l'adresse " <<
(int*)shared_memory << endl;

/* Détermine la taille du segment en octets. */

shmctl (id, IPC_STAT, &shmbuffer);

segment_size = shmbuffer.shm_segsz;

cout << "taille du segment : "<< segment_size << endl;

/* Écrit la chaîne temp dans le segment de mémoire partagée à l'aide

d'une fonction en C * qui utilise justement comme 1er paramètre un
pointeur sur une chaîne de caractères */

string temp = "Hello world. " ;

strcpy(shared_memory, temp.c_str());
/* Détache le segment de mémoire partagée. */

shmdt (shared_memory);

/* Réattache le segment de mémoire partagée à une adresse différente. */

shared_memory = (char*) shmat (id, (const void *)0x5000000, 0);

cout << "Mémoire partagée attachée à l'adresse " << (int *)shared_memory << endl;

/* Affiche la chaîne de la mémoire partagée. */

cout << "Chaine de sortie : "<< shared_memory << endl;

/* Détache le segment de mémoire partagée. */

shmdt (shared_memory); shmctl(id, IPC_RMID, 0);

/* Libère le segment de mémoire partagée. */

return 0;

Exercice (à remettre la semaine prochaine et à effectuer en binôme)

N.B : Rapport max deux pages

écrire un programme qui permet qu'un processus écrive un message
dans une mémoire partagée que ses 2 fils liront, afficheront, puis
qu'il compléteront en rajoutant à la suite du message leur numéro de
processus.