Discussion :

[godskitchen]

Bonjour à tous,

Je me suis récemment initié au partage de données entre deux applications C via la mémoire partagée sur UNIX en utilisant le standard POSIX (shmget...). J'ai réussi à partager une structure de donnée contenant plusieurs champs sans problèmes (je précise que je ne fais pas d'allocation dynamique). A présent, j'ai une multitude de données à transférer de types différents : int*, char*, struct...
Quel est le meilleur moyen pour partager ses données ? J'ai pensé à mettre toute les informations de ces données au sein d'une meta-structure et partager celle-ci... Des suggestions ?

Merci d'avance

[Médinoc]

Les structures peuvent être passées telles quelles, ce sont les pointeurs qui ne peuvent pas. Tu dois t'arranger pour tout avoir dans une ou plusieurs zone(s) de mémoire partagée indépendante(s) des adresses.
Par contre, tu peux utiliser des indexes de tableau, ou des offsets depuis le début de ta mémoire partagée: Tout ça c'est du relatif, et donc indépendant de la position absolue en mémoire.

[ternel]

Bonjour,
De base, les pointeurs ne peuvent pas être partagés, car chaque programme à son propre espace d'adressage.
l'adresse 17 de l'un n'est pas la 17 de l'autre...

C'est à peu près tout ce que j'en sais…

[godskitchen]

Je vous remercie de votre réponse.

Tout d'abord une petite disgression...Il est tout a fait possible de partager des pointeurs à condition qu'il n'ait pas été dynamiquement alloués. En effet, ces derniers pointeront sur des données se trouvant dans le tas qui est exclusif à un processus. Autrement, les données pointées se trouvent sur la pile et la mémoire partagée ne pose pas de problèmes. Ceci ayant été testé par mes soins. J'ai crée une structure de type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
typedef struct
{
    int age;
    char nom[128];
    int *ageEnfant[2];
 
} identite;

et la variable que j'ai partagé est de type identite*. Les données écrites dans l'un des processus sont correctement lues par l'autre processus.

Tu sais que tu n'auras jamais plus de X valeurs, X etant un nombre raisonnable (c'est a dire pas 3 millions). Dans ce cas, tu peux allouer le nombre maximum d'entiers (char) dans ta memoire partagee.

Je sais exactement les données que je veux partager et a fortiori leurs tailles. En allouant le nombre maximum d'entier dans ma mémoire partagée - donc avec un char - puis-je mettre des données de types qui sont distincts du type char dans cette mémoire? Dans le cas échéant, comment puis-je mettre à la suite plusieurs données, par exemple une struct, un int et une autre struct ?
Faut-il utiliser des offsets pour naviguer entre les élèments de ma zone mémoire comme suggéré par médinoc ?

[Médinoc]

Je vous remercie de votre réponse.

Tout d'abord une petite disgression...Il est tout a fait possible de partager des pointeurs à condition qu'il n'ait pas été dynamiquement alloués. En effet, ces derniers pointeront sur des données se trouvant dans le tas qui est exclusif à un processus. Autrement, les données pointées se trouvent sur la pile et la mémoire partagée ne pose pas de problèmes. Ceci ayant été testé par mes soins. J'ai crée une structure de type

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
typedef struct
{
    int age;
    char nom[128];
    int *ageEnfant[2];
 
} identite;

et la variable que j'ai partagé est de type identite*. Les données écrites dans l'un des processus sont correctement lues par l'autre processus.

Normalement, ça ne doit pas marcher avec ageEnfant.
Par contre, si ton processus est issu d'un fork() sans exec(), il y a une chance qu'un pointeur vers des données de la pile soit valide dans les deux processus... Mais il pointera vers deux zones mémoires différentes.
Ensuite, si la mémoire partagée est déjà mappée avanc le fork(), alors oui dans ce cas elle sera à la même adresse dans les deux processus (ce qui fait que les pointeurs vers l'intérieur de la mémoire partagée seront valides des deux côtés et pointeront bien sur la même donnée). Mais ce n'est pas le cas général (ex: ça n'est pas garanti marcher si la mémoire est mappée après le fork()).

Je sais exactement les données que je veux partager et a fortiori leurs tailles. En allouant le nombre maximum d'entier dans ma mémoire partagée - donc avec un char - puis-je mettre des données de types qui sont distincts du type char dans cette mémoire? Dans le cas échéant, comment puis-je mettre à la suite plusieurs données, par exemple une struct, un int et une autre struct ?
Faut-il utiliser des offsets pour naviguer entre les élèments de ma zone mémoire comme suggéré par médinoc ?

Dans tous les cas, tu pourras toujours mettre tes données existantes dans une struct qui englobe tout:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
struct s_mem
{
	struct s_uneStruct uneStruct;
	int unInt;
	struct s_uneAutreStruct uneAutreStruct;
}

[godskitchen]

Je m'excuse j'ai fait une erreur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
typedef struct
{
    int age;
    char nom[128];
    int ageEnfant[2];
 
} identite;

Je m'étais trompé dans la syntaxe pour définir ageEnfant. A présent, il n'y a pas de raison pour que la mémoire partagée ne soit pas adéquate pour partager cette structure, vous êtes d'accord ? Pour info, il s'agit de deux processus totalement indépendant (pas de fork...).

Ok pour la solution de tout mettre dans une grosse structure.

[Médinoc]

Là oui je suis parfaitement d'accord, ça devrait marcher dans tous les cas.

[gangsoleil]

A présent, j'ai une multitude de données à transférer de types différents : int*, char*, struct...
Quel est le meilleur moyen pour partager ses données ? J'ai pensé à mettre toute les informations de ces données au sein d'une meta-structure et partager celle-ci... Des suggestions ?

Comme il a ete dit, partager un pointeur n'est pas possible (enfin si, mais non), et ce n'est probablement pas ce que tu veux faire.

Je pense que ce que tu veux faire, c'est partager plusieurs entiers (resp. caracteres), qui sont manipules dans ton programme dans un int* (resp. char*).
Dans ce cas, plusieurs possibilites :

1. Tu sais que tu n'auras jamais plus de X valeurs, X etant un nombre raisonnable (c'est a dire pas 3 millions). Dans ce cas, tu peux allouer le nombre maximum d'entiers (char) dans ta memoire partagee.
2. Il n'y a pas de limite superieure : soit tu peux utiliser une partie seulement des donnees, et tu te retrouves dans le premier cas, soit tu ne peux pas, et dans ce cas le segment de memoire partagee n'est pas adapte a ce que tu veux faire.