Mémoire partagée et pointeur

Bonjour,

J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.

J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)

Je ne suis pas sûr de m'être bien expliqué.
Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(

Si tu es sous Win32, utilise le File Mapping. Cela te permettra d'avoir une zone mémoire allouée par le système et nommée, c'est-à-dire que tu pourrais y accéder à partir de n programmes.

Kaid - kaid.fr.st

-------------------------------
Réponse au message :
-------------------------------

> Bonjour,
>
> J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
>
> J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
>
> Je ne suis pas sûr de m'être bien expliqué.
> Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(

Pour une fois chapeau, question bien posee et tres claire.
Effectivement tu ne passeras pas une adresse memoire d'un processus a un autre car elle sera toujours invalide.
Ici ta solution sera un CreateFileMapping (voir dans MSDN) avec nom ou dans le fichier d'echange du systeme et place les donnees dedans, l'autre processus pourra les lire et modifier si besoin.
BruNews, ciao...


-------------------------------
Réponse au message :
-------------------------------

> Bonjour,
>
> J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
>
> J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
>
> Je ne suis pas sûr de m'être bien expliqué.
> Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(

héhé, je me doutais que tu répondrais, j'ai en effet utilisé le programme sur ton site qui se sert du File Mapping mais ça ne marche pas snif.

Du côté serveur ça passe bien, le remplissage est ok, la lecture aussi, mais côté client ça passe moins bien, toujours un nombre qui n'a rien à voir avec le remplissage.

Au moins ça me rassure qu'on me dise d'utiliser ça, ça veut dire que c'est juste que je m'y prends mal :).


-------------------------------
Réponse au message :
-------------------------------

> Si tu es sous Win32, utilise le File Mapping. Cela te permettra d'avoir une zone mémoire allouée par le système et nommée, c'est-à-dire que tu pourrais y accéder à partir de n programmes.
>
> Kaid - kaid.fr.st
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > Bonjour,
> >
> > J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
> >
> > J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
> >
> > Je ne suis pas sûr de m'être bien expliqué.
> > Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(
>

Merci pour la question bien posée :)

Comme je dis à Kaid, je passe par un FileMapping (j'ai modifié son programme client/serveur). Mais tout ce qui est allocation dynamique (new, int* =, templates) donne le même résultat.
J'ai cherché sur pas mal de forums, je n'ai croisé que des "échanges" de structures statiques.

-------------------------------
Réponse au message :
-------------------------------

> Pour une fois chapeau, question bien posee et tres claire.
> Effectivement tu ne passeras pas une adresse memoire d'un processus a un autre car elle sera toujours invalide.
> Ici ta solution sera un CreateFileMapping (voir dans MSDN) avec nom ou dans le fichier d'echange du systeme et place les donnees dedans, l'autre processus pourra les lire et modifier si besoin.
> BruNews, ciao...
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > Bonjour,
> >
> > J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
> >
> > J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
> >
> > Je ne suis pas sûr de m'être bien expliqué.
> > Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(
>

Mais les autres valeurs sont t'elles exactes ? Si une seule valeur est erronée, cela ne doit pas être grand chose. Attention toute fois à la syncro entre le serveur et le client, tu peux utiliser un événement nommé, quand le serveur a terminé le remplissage pour le signifier au client.

Kaid - kaid.fr.st

-------------------------------
Réponse au message :
-------------------------------

> héhé, je me doutais que tu répondrais, j'ai en effet utilisé le programme sur ton site qui se sert du File Mapping mais ça ne marche pas snif.
>
> Du côté serveur ça passe bien, le remplissage est ok, la lecture aussi, mais côté client ça passe moins bien, toujours un nombre qui n'a rien à voir avec le remplissage.
>
> Au moins ça me rassure qu'on me dise d'utiliser ça, ça veut dire que c'est juste que je m'y prends mal :).
>
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > Si tu es sous Win32, utilise le File Mapping. Cela te permettra d'avoir une zone mémoire allouée par le système et nommée, c'est-à-dire que tu pourrais y accéder à partir de n programmes.
> >
> > Kaid - kaid.fr.st
> >
> > -------------------------------
> > Réponse au message :
> > -------------------------------
> >
> > > Bonjour,
> > >
> > > J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
> > >
> > > J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
> > >
> > > Je ne suis pas sûr de m'être bien expliqué.
> > > Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(
> >
>

Les entiers (int entier1; int entier2) sont oks, pour le tableau d'entiers (int* tab1) l'adresse est la même, mais quand je lis tab1[i] les valeurs sont inexactes (d'ailleurs sur un tableau de 2 éléments j'ai toujours la même valeurs dans les 2 "cases").

Pour la synchro je n'en ai pas fait, je lance le serveur et une fois les instructions de remplissage terminées je lance le client.

-------------------------------
Réponse au message :
-------------------------------

> Mais les autres valeurs sont t'elles exactes ? Si une seule valeur est erronée, cela ne doit pas être grand chose. Attention toute fois à la syncro entre le serveur et le client, tu peux utiliser un événement nommé, quand le serveur a terminé le remplissage pour le signifier au client.
>
> Kaid - kaid.fr.st
>
> -------------------------------
> Réponse au message :
> -------------------------------
>
> > héhé, je me doutais que tu répondrais, j'ai en effet utilisé le programme sur ton site qui se sert du File Mapping mais ça ne marche pas snif.
> >
> > Du côté serveur ça passe bien, le remplissage est ok, la lecture aussi, mais côté client ça passe moins bien, toujours un nombre qui n'a rien à voir avec le remplissage.
> >
> > Au moins ça me rassure qu'on me dise d'utiliser ça, ça veut dire que c'est juste que je m'y prends mal :).
> >
> >
> > -------------------------------
> > Réponse au message :
> > -------------------------------
> >
> > > Si tu es sous Win32, utilise le File Mapping. Cela te permettra d'avoir une zone mémoire allouée par le système et nommée, c'est-à-dire que tu pourrais y accéder à partir de n programmes.
> > >
> > > Kaid - kaid.fr.st
> > >
> > > -------------------------------
> > > Réponse au message :
> > > -------------------------------
> > >
> > > > Bonjour,
> > > >
> > > > J'essai de faire passer un tableau dynamique, un pointeur donc, d'un programme à un autre, l'adresse est bien passée et les champs non dynamique de la struct aussi (int et compagnie), mais le programme qui la reçoit n'arrive pas à accéder aux éléments du tableau.
> > > >
> > > > J'ai tout de suite pensé que l'adresse du tableau dynamique était relative à la zone mémoire du programme qui avait créé le tableau (j'ai testé avec un "new" mais aussi avec un "int tabX[2]; tab = tabX;" mais c'est pareil évidemment) et que c'est pour ça que le second ne trouvait rien à l'adresse indiqué, y'a-t-il un moyen de faire pointer le second où il faut ? (par exemple en récupérant l'adresse de début de la zone mémoire du 1er programme et en l'ajoutant à l'adresse du tableau)
> > > >
> > > > Je ne suis pas sûr de m'être bien expliqué.
> > > > Si ce n'est pas possible ça va m'obliger à placer des tableaux de grosse taille dans la struct, ça m'embêterait beaucoup :(
> > >
> >
>

Les variables créées dynamiquement attérissent dans la pile du processus qui les crée, c'est-à-dire que l'adresse est effectivement relative au processus.

Le problème a été réglé, pour l'instant ce n'est pas formulé à l'écrit mais la méthode est arrêté, elle marche et n'est pas une usine à gaz (bien :), j'essaierai de mettre la source ici après nettoyage des fonctions liées au projet d'ici quelques mois au plus.

-------------------------------
Réponse au message :
-------------------------------

> Les entiers (int entier1; int entier2) sont oks, pour le tableau d'entiers (int* tab1) l'adresse est la même, mais quand je lis tab1[i] les valeurs sont inexactes (d'ailleurs sur un tableau de 2 éléments j'ai toujours la même valeurs dans les 2 "cases").
>
> Pour la synchro je n'en ai pas fait, je lance le serveur et une fois les instructions de remplissage terminées je lance le client.