Communication entre programmes par mémoire partagée
Bonjour à tous,
Je suis ici aujourd'hui car je souhaite faire communiquer deux programmes entre eux via un espace en mémoire partagé.
J'ai un programme qui crée un segment mémoire partagée, puis qui récupère les informations qui se trouve dans ce segment.
Puis un second programmes qui doit écrire à l'intérieur de ce segment mémoire.
Voici le code de mon premier programme.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
|
int main()
{
StructAdresse adresseA_Envoyer;
creerMp(&adresseA_Envoyer);
//Enregistrement des adresses de reception et d'émission
void * reception = adresseA_Envoyer.adresse_buffer_reception;
void * emission = adresseA_Envoyer.adresse_buffer_emission;
//Définition des structures qui permettrons d'échanger avec le buffer.
StructBuffer structReception;
StructBuffer structReceptionTemp;
StructBuffer structEnvoi;
//initialisation d'un des élément des structures
strcpy(structReceptionTemp.trame,"null2");
strcpy(structReception.trame,"vide");
//DEBUG
strcpy(structEnvoi.nomDst,"nom destination 16");
strcpy(structEnvoi.nomSrc, "nom source 16");
strcpy(structEnvoi.trame, "null");
int i=0;
printf("adresse reception : %p\n",reception);
printf("adresse emission : %p\n\n",emission);
*((StructBuffer*)reception)=structEnvoi;
while(i<30){
i++;
//Lecture message en attente dans le buffer.
structReception = *((StructBuffer*)reception);
printf("Message reçu : %s\n",structReception.trame);
sleep(1);
if(strcmp(structReception.trame,structReceptionTemp.trame)!=0){
printf("Nouveau message reçu depuis %s\n",structReception.nomSrc);
printf("\t Message : %s",structReception.trame);
strcpy(structReceptionTemp.trame,structReception.trame);
}
}
fermerMp(&adresseA_Envoyer);
return 0;
} |
Voici la fonction utilisé pour créer l'espace mémoire
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
void creerMp(StructAdresse * aEnvoyer)
{
char* mem_IDR = (char*) malloc(100*sizeof(char));
char* mem_IDE = (char*) malloc(100*sizeof(char));
mem_IDR = "sharedMemoryR";
mem_IDE = "sharedMemoryE";
//L'instruction ftok(name, (key_t) cle) permet de construire une cle identifiant le segment
key_t clefR = ftok(mem_IDR, (key_t) CLEFA_R);
key_t clefE = ftok(mem_IDE, (key_t) CLEFA_E);
IDR = shmget(clefR,8, IPC_CREAT | IPC_EXCL|SHM_R|SHM_W);
IDE = shmget(clefE,8, IPC_CREAT | IPC_EXCL|SHM_R|SHM_W); /* Je cherche le segment de mémoire associé
à la CLEF et je récupère l'identificateur de ce segment mémoire.*/
if (IDR<0 || IDE<0)
{
IDR=0;
IDE=0;
IDR = shmget(clefR,8,0666);
IDE = shmget(clefE,8,0666);
if (IDR<0 || IDE<0)
{
puts("la création du segment de mémoire à échoué");
perror("shmget"); // Je m'assure que l'espace mémoire a correctement été crée.
exit(1);
}
}
/* J'attache le segment de mémoire partagée identifié par mem_ID_R au segment de
donnée du processus de Reception dans une zone libre déterminée par l'OS*/
aEnvoyer->adresse_buffer_emission = shmat(IDE, NULL,0);
aEnvoyer->adresse_buffer_reception = shmat(IDR, NULL,0);
aEnvoyer->shmid_emission = IDE;
aEnvoyer->shmid_reception = IDR;
if(aEnvoyer->adresse_buffer_reception == (void*)-1)
{
puts("Un problème est survenue lors de l'afféctation du segment mémoire crée");
perror("shmat");// Je m'assure que le segment de mémoire à été correctement attaché au process.
exit(1);
}
if(aEnvoyer->adresse_buffer_emission == (void*)-1)
{
puts("Un problème est survenue lors de l'afféctation du segment mémoire crée");
perror("shmat");// Je m'assure que le segment de mémoire à été correctement attaché au process.
exit(1);
}
} |
Et voici le code du second programme qui doit venir écrire à l'intérieur du segment mémoire.
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
StructBuffer aEnvoyer;
//MàJ de la structure "aEnvoyer" qui va être écrite dans le buffer de reception du prog DST
strcpy(aEnvoyer.nomDst, "nomdstTest");
strcpy(aEnvoyer.trame, "trameTest");
strcpy(aEnvoyer.nomSrc, "nomSrcTest");
recupAdresseBufferReception_Nom(&aEnvoyer);
printf("Le programme source est : %s\n",aEnvoyer.nomSrc);
printf("Le programme de destination est : %s \n",aEnvoyer.nomDst);
printf("Message transmit : %s\n",aEnvoyer.trame);
printf("\tAdresse cible pour l'écriture : %p\n\n",aEnvoyer.ptr_adresse_buffer);
//Récupération des info lié au segment de mémoire partagé
recupSegmentMemoire();
//Ecriture dans le buffer du premier programme
*((StructBuffer*)aEnvoyer.ptr_adresse_buffer)=aEnvoyer;
puts("message ecrit dans le buffer"); |
Et voici la fonction que j'utilise pour récupérer l'accès au segment mémoire
Code:
1
2
3
4
5
6
7
8
9
10
11
12
|
void recupSegmentMemoire()
{
printf("\n\n --SHMID-- : %d\n",carnetAdresses[0].shmid_reception);
if((shmctl(carnetAdresses[0].shmid_reception,IPC_STAT,NULL))!=0){
puts("problème lors de l'accès au segment mémoire");
perror("Shmctl : ");
exit(EXIT_FAILURE);
}
} |
Et enfin voici la structure structBuffer
Code:
1
2
3
4
5
6
7
8
|
struct StructBuffer{
int synchro;
char nomDst[40];
char nomSrc[40];
char trame[40];
void* ptr_adresse_buffer;
}; |
Voilà pour mon code, donc toute la partie lié au premier code fonctionne comme je le souhaite, en tout cas en apparence. Pour le second programme je récupère bien toutes les informations que je souhaite.
Par contre je n'arrive pas à accéder à l'espace mémoire créer depuis le second programmes.
J'ai essayé plusieurs méthodes et j'ai fait de nombreuses recherches mais je n'arrive pas a trouver la solutions à mon problèmes.
Je vous remercie pour vos pistes et votre aide. :)
