C++

[C/C++] Dialoguer avec un processus fils

Recherche :

Mot : Pseudo : Filtrer
Page : 1 2 Page Suivante Page Précédente Bas de page
Auteur	Sujet : [C/C++] Dialoguer avec un processus fils

antsite

Je me souviens

Salut,
Je chercher si c'est possible, comment un child proc pourrait dialoguer avec son parent (échange d'infos, signaux,...).
Pour le moment je pensais le faire avec écriture dans un fichier mais bon ça doit pas être le top (le fils écrit dans le fichier, et le parent lit tant que...
merci
ANT

edit: pour la création du process ben ça peut être ce que vous voulez, CreateProcess,...

Message édité par antsite le 03-05-2003 à 16:18:02

Publicité

zarmaras

non, c'est pas possible, c'est la que tu vois que le C ca commence a dater, paske c'est pas tres pratique.

Je sais pas exactement comment ca marche, mais je sais qu'avec les stream (me souviens plus bien du nom, mais il me semble que c'est "stream" ), c'est possible, mais la il faut que tu fasses des recherches, paske j'y connais rien, je sais juste que ca existe et kya kavec ca que tu peux echanger des donnees entre pere et fils.

voila, jespere que ca t'aide, bon courage

verdoux

And I'm still waiting

Tu peux voir du côté des pipes (qui existent sous unix et sous windows)

zarmaras

me suis plante, le nom du truc en question c'est "threads"

antsite

Je me souviens

Oui en effet les pipes ont l'air d'être ce qu'il me faut mais, de plus dans msdn y a des exemples qui ont l'air pas mal mais vraiment trop compilqués! Personne peut me donner un bout de code comment le fils peut envoyer un signal au père (mettre une variable à 1 et que cette variable soit lisible par père & fils)...

http://msdn.microsoft.com/library/ [...] __pipe.asp

Merci à l'ame charitable qui me vulgarisera un des ces 2 exemples ! :hello:

antsite

Je me souviens

Bon en fait les exemples sont pas trop durs, voila ce que j'en ai tiré mais évidemment ça marche pas:
test.cpp

Code :

enum PIPES { READ, WRITE }; //READ = 0 ; WRITE = 1
int main(void)
{
int hpipe[2];
int termstat, pid;
char hstr[20];
_pipe(hpipe, 256, O_BINARY);
itoa(hpipe[READ], hstr, 10);
pid = spawnl(P_NOWAIT, "test2.exe", "test2.exe", hstr, NULL);
printf("write\n" );
for(int i=0;i<10;i++)
{
printf("-%d-\n", i);
write(hpipe[WRITE], (char*)&i, sizeof(int));
}
cwait(&termstat, pid, WAIT_CHILD);
close(hpipe[READ]);
close(hpipe[WRITE]);
return EXIT_SUCCESS;
}

test2.cpp

Code :

enum PIPES { READ, WRITE }; //READ = 0 ; WRITE = 1
int main(int argc, char *argv[])
{
int hpipe[2];
int i;
hpipe[READ] = atoi(argv[1]);
printf("\nread\n" );
for(int n=0;n<10;n++)
{
read(hpipe[READ], (char*)&i, sizeof(int));
printf("+%d+\n", i);
}
close(hpipe[READ]);
close(hpipe[WRITE]);
return EXIT_SUCCESS;
}

sortie (quand je lance test.exe):
write
-0-
-1-
-2-
-3-
-4-
-5-
-6-
-7-
-8-
-9-

read
+1+
+1+
+1+
+1+
+1+
+1+
+1+
+1+
+1+
+1+

je ne comprends pas, merci de votre aide !

mrbebert

C'est quoi cette fonction spawnl :??:

sombresonge

Essaie de faire une zone de memoire commune (GlobalAlloc en win32)

philou_a7

\_o< coin ! >o_/

Heu si, c'est parfaitement possible : renseigne toi sur les segments de memoire partagés ('shm' sous les unices)
C'est une zone memoire que tu alloues dans un process avec un identifiant reutilisable par d'autres process tu peut y stocker et y lire à peu pres ce que tu veux

le C n'est pas dépassé quand on sait s'en servir :hello:

antsite

Je me souviens

Oui en effet les shm ça à l'air très intéressant! Voila ce que j'ai trouvé, mais je suis sous windows et les fonctions shm... n'existent pas j'ai l'impression... comment faire ?

http://digilander.libero.it/robang [...] ool.c.html

Et pour mes pipes personnes n'a d'idée ?

Message édité par antsite le 04-05-2003 à 12:09:09

Publicité

Taz

bisounours-codeur

zarmaras a écrit :

me suis plante, le nom du truc en question c'est "threads"

c toi qui date pas le C

antsite

Je me souviens

up !

Jam Kuradoberi

Guilty Gear X , uniquement !

ANT tu est sur unix ou windows ?

dans tous les cas tu peux utiliser soit des pipes soit des signaux, mais les signaux sont peu pratiques. Je parle ici pour unix car je sais pas du tout comment ca marche sous win on voit pas ca en cours, par contre sous unix c pas dur.

du meme coup si tu taff sou win tu pourrais me dire comment on crée un processus fils ?

antsite

Je me souviens

Salut,
ALors oui je suis sous windows mais si tu regardes le code que j'ai posté ci dessus je pense qu'il est standard donc tu vois pas pourquoi ça marche pas?
Ben pour créer un processus fils: CreateProcess, spawn/ exec,...

:hello:

Jam Kuradoberi

Guilty Gear X , uniquement !

euh non c pas standard du tout ca depend du systeme sur lequel tu travaille... Sous unix tu utilises les primitives Unix (fork exec pipe select kill).

jpeu t'expliquer toute la theorie que tu veux et aussi la pratique sous unix mais sous windows je connais pas du tout. je pense que seules les primitives systemes changent, mais sinon le principe doit etre le meme.

:hello:

antsite

Je me souviens

excuse moi mais peux tu me dire où mon code n'est pas standard ?

Jam Kuradoberi

Guilty Gear X , uniquement !

skoi spawnl ?

bah je connais pas CreateProcess moi en unix on utilise fork()

antsite

Je me souviens

Oui biensur CreateProcess c'est de l'API win32 mais spawnl tout comme execl,v ,e,... ben c'est standard (enfin je pense!)

Jam Kuradoberi

Guilty Gear X , uniquement !

ok disons que c'est standard je vais regarder un peu au code des que j'ai 5 minutes ^^

antsite

Je me souviens

:sweat:

antsite

Je me souviens

:bounce:

mrbebert

Ce sont bien 2 processus différents, ou seulement 2 threads d'un même processus ?
Dans le 2ème cas, c'est nettement plus simple

Jam Kuradoberi

Guilty Gear X , uniquement !

euh si le prog test lance le prog test2, je comprend pas pourkoi ta des pipes dans test2 ...

ton prog test2 tu le fais lire et ecrire sur l'entree et la sortie standard

le prog test cree les 2 pipes, 1 qui fait pere -> fils et l'autre qui fait fils -> pere, ensuite dans le travail du fils tu redirige l'entree et la sortir standard vers les pipes (en unix la primitive c'est DUP() ou DUP2() ), apres le pere a pu ka lire et ecrire dans les pipes pour dialoguer avec son fils.

voila j'espere que j'ai ete clair, si c'eat pas le cas je recopierais ici un ptit exo qui dois trainer dans une de mes pochettes de cours ^^

Jam Kuradoberi

Guilty Gear X , uniquement !

ANTSite a écrit :

j'avais pas vu ce message detrompes toi les pipes c'est vraiment super simple, jvei trouver un bout de code qu'on a fait et jle pasterais ici des que j'ai le temps tu va voir c'est pas dur, t'aura juste a trouver l'equivalent windows des primitives unix dont je me sert :]

bjone

Insert booze to continue

zarmaras a écrit :

heu le langage ça a aucune rapport avec les ipcs, mé ché pas grave...

antsite

Je me souviens

Jam Kuradoberi a écrit :

Oui voila nickel (laisse tomber les exemples MSDN). Oui je comprends en gros mais franchement j'aimerais bien un bout de code quand même!

polo021

j'ai pas tout lu mais voici un exemple ou un processus pere communique avec son fils par pipe

Code :

#include<stdio.h>
#include<fcntl.h>
void main (void)
{
int i,j,l,a,b,k,m;
int tab[20];
int fich;
int p[2];
creat("tri.txt",00666);
pipe(p);
i=fork();
if (i!=0)
{
printf ("Processus pere\n" );
for (j=0;j<20;j++)
{
printf("\nEntrez le nombre %d : ",j+1);
scanf("%d",&a);
write(p[1],&a,sizeof(int));
}
close( p[1]);
wait(0);
fich= open ("tri.txt",O_RDONLY);
read(fich,tab,20*(sizeof(int)));
for (k=0;k<20;k++)
{
printf ("%d\n",tab[k]);
}
close (fich);
}
else
{
printf("\nprocessus fils\n" );
for (k=0;k<20;k++)
{
read(p[0],&b,sizeof(int));
l=0;
while ((l<k)&&(tab[l]<b))
{
l++;
}
for (m=k;m>l;m--)
{
tab[m]=tab[m-1];
}
tab[l]=b;
}
fich= open ("tri.txt",O_WRONLY);
printf("fichier : %d",fich);
write(fich,tab,20*(sizeof(int)));
perror("write" );
close(fich);
}}

le processus pere saisi 20 nombres, les envoie a son fils par un pipe, le fils receptionne les nombres, les trie et les ecrits dans un fichier.
Ensuite le pere va lire les nombres dans le fichier et les affiches (ils sont donc triés).
Fonctionne sous Unix

EDIT : je viens de voir que t'etais sous win, mais cet exemple peut peut-etre t'aider quand meme a voir le principe de fonctionnement des pipes

Message édité par polo021 le 10-05-2003 à 19:56:37

antsite

Je me souviens

le problème tu vois c'est que j'ai en gros le même exemple sous windows avec msdn et c'est ce que j'ai posté (mon code plus haut) car ça ne marche pas. C'est sensiblement le même tu en penses quoi, pourquoi ça marche pas?

> Jam Kuradoberi, tu penses à mon exemple avec dup / dup2 :hello:

Sigmund

Je ne sais pas si cela existe en win32 mais sinon tu pourrais utiliser des files de messages... là c'est franchement dur de faire plus simple !

bjone

Insert booze to continue

ANTSite a écrit :

le problème avec le spawnl, c'est qu'un noveau processus est crée, mais un segment de donnée "initial".

quand tu forkes, le processus fils a une "copie" du segment de donnée du processus père.
quand tu spawnes, le process crée est un nouveau process tout clean (tu refais un père)

chez crosoft, ils ont décidé de favoriser l'approche multi-thread, au lieu de l'approche multi-process d'unix.
donc le mieux avec windows, c'est de faire de créer des threads.

bjone

Insert booze to continue

http://www.experts-exchange.com/Pr [...] 62938.html

symétriquement, il faut savoir que contrairement à unix/linux, toute communication inter-process est tué quand plus aucuns processus l'utilise (y'a un compteur d'utilisation)

alors que sous unix/linux, quand tu crées une mémoire partagée/sémaphore/etc etc..., quand tous tes process meurent sans les détruire, ils restent et fo passer derrière avec ipcs.

Message édité par bjone le 11-05-2003 à 00:20:46

bjone

Insert booze to continue

tiens un exemple de threads+sync que je me garde sous la main au cas où:

à coller dans un projet console/win32 (attention au stdafx.h au cas ou y'en aurait poa)

Code :

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
// messages par threads
char msg1[]="Thread1 AZERTY";
char msg2[]="Thread2 UIOP";
char msg3[]="Thread3 YAKAYA";
CRITICAL_SECTION CSec; // (1) sync par section critique
HANDLE hSemaphore; // (2) sync par sémaphore
HANDLE hMutex; // (3) sync par mutex
void timed_puts(char *s)
{
while( *s )
{
putc(*s,stdout);
fflush(stdout);
Sleep(100 + (rand()&63) );
s++;
}
putc('\n',stdout);
fflush(stdout);
}
DWORD WINAPI ThreadFunc( LPVOID lpParam )
{
int i;
for( i = 0 ; i < 3 ; i++)
{
//EnterCriticalSection(&CSec); // (1) sync par section critique
//WaitForSingleObject(hSemaphore,INFINITE); // (2) sync par sémaphore
WaitForSingleObject(hMutex,INFINITE); // (3) sync par mutex
/////////////////////////////////////////
timed_puts( (char*) lpParam ); // affichage
////////////////////////////////////////
ReleaseMutex(hMutex); // (3)
//ReleaseSemaphore( hSemaphore, 1, NULL); // (2)
//LeaveCriticalSection(&CSec); // (1)
}
return 0;
}
int main(int argc, char* argv[])
{
//////////////////////////////////////
////////////////////////////////////// Création des primites de sync
//////////////////////////////////////
// InitializeCriticalSection(&CSec); // (1) sync par section critique
// hSemaphore = CreateSemaphore( NULL,1,1,NULL ); // (2) sync par sémaphore
hMutex=CreateMutex(NULL,false,NULL); // (3) sync par mutex
//////////////////////////////////////
//////////////////////////////////////
//////////////////////////////////////
// Création des threads
HANDLE hTh[3];
DWORD dwTh[3];
hTh[0]=CreateThread(NULL,0,ThreadFunc,&msg1,CREATE_SUSPENDED ,&dwTh[0]); // thread 0 suspendu
hTh[1]=CreateThread(NULL,0,ThreadFunc,&msg2,0 ,&dwTh[1]); // thread 1 & 2 démarrent tout de suite
hTh[2]=CreateThread(NULL,0,ThreadFunc,&msg3,0 ,&dwTh[2]);
if( hTh[0]==NULL || hTh[1]==NULL || hTh[2]==NULL )
{
printf("CreateThread() a echoue.\n" );
return 1;
}
ResumeThread(hTh[0]); // on autorise le thread 0 à s'éxécuter
// ReleaseMutex(hMutex); // on lache tout via le mutex si il est créé avec true
// attente fin de vie des threads (les 3 simultanés)
WaitForMultipleObjects(3,hTh,true,INFINITE);
// fermeture des handles de threads
CloseHandle(hTh[0]);
CloseHandle(hTh[1]);
CloseHandle(hTh[2]);
/////////////////////////////////////
///////////////////////////////////// destruction des primites de syncs
/////////////////////////////////////
CloseHandle(hMutex);
// CloseHandle(hSemaphore);
// DeleteCriticalSection(&CSec);
//////////////////////////////////////
return 0;
}

Message édité par bjone le 11-05-2003 à 00:25:29

bjone

Insert booze to continue

Et là un exemple de mémoire partagée uniquement:

lancer deux fois l'éxécutable, le premier process crée, le deuxieme l'utilise.

ne pas oublier que toute mémoire partagée doit être accompagnée d'un sémaphore, hormis cas particuliers, sinon ton prof te mettera deux claques.

bin dans cet exemple y'a pas de sémaphore

Code :

#include "stdafx.h"
#include <windows.h>
#include <stdio.h>
#include <iostream.h>
#define SHMEMSIZE 64
int main(int argc, char* argv[])
{
HANDLE hMapObject=NULL;
char *Shm=NULL;
BOOL ShmCreator;
// création de l'objet partagé (pas fichier car INVALID_HANDLE_VALUE )
if( hMapObject = CreateFileMapping( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, SHMEMSIZE, "bjone.shmtest" ), !hMapObject )
return 1;
ShmCreator=(GetLastError() != ERROR_ALREADY_EXISTS);
// mappage de l'objet en mémoire
if( Shm = (char*)MapViewOfFile( hMapObject, FILE_MAP_WRITE, 0, 0, 0), !Shm )
return 2;
printf( "Handle: %x\n"
"Offset memoire partagee: %p\n\n'q' pour quitter.\n\n",hMapObject,Shm);
if( ShmCreator )
cout<<"Process createur de memoire partagee.\n";
else
cout<<"Process non-createur de memoire partagee.\n";
char BUFFER[SHMEMSIZE];
do {
printf("%s\n",Shm);
cin.getline(BUFFER,SHMEMSIZE);
if( BUFFER[0] )
memcpy(Shm,BUFFER,SHMEMSIZE);
} while( Shm[0]!='q');
UnmapViewOfFile(Shm);
CloseHandle(hMapObject);
return 0;
}

voila je ne vois pas d'autres explications pour ce qui est du win32

si j'ai dit des conneries je m'en excuse à l'avance :jap:

PS: bien évidemment dans le cas d'une appli multi-threadée, la mémoire partagée n'a aucun sens, puisque les threads utilisent le même segment de code & de donnée (mais contexte différent).

Message édité par bjone le 11-05-2003 à 00:51:27

mrbebert

Très intéressant tout ca :jap: :jap:

bjone

Insert booze to continue

au fait je viens de m'apercevoir que faire un CTRL-C & co peut faire péter les plombs au code [:sisicaivrai]

bjone

Insert booze to continue

BJOne a écrit :

au fait je viens de m'apercevoir que faire un CTRL-C & co peut faire péter les plombs au code [:sisicaivrai]

a non c'est bon quand on est pas sous l'ide en mode debug [:the one]

antsite

Je me souviens

Merci pour tout ça
Alors oui les threads disons que je m'en sert assez régulièrement donc j'ai pas trop de problème la dessus.

Par contre le shm je ne connais pas du tout, tu pourrais m'indiquer où employer sémaphore (en gros un WaitSingleObject qu'il faut non ?)
C'est que j'aimerais faire un truc propre quand même ;-)

bjone

Insert booze to continue

ANTSite a écrit :

bin sous unix (ou sous windows), si tu as deux process qui accèdent une mémoire partagée, suivant ce que contient la mémoire partagée il faut mettre un sémaphore lors de l'accès/modification de la mémoire partagée.

passke si tu as un process qui génére des informations dans la mémoire partagée, et l'autre qui les consommes, il peut y avoir un basculement de tâche au moment ou le process généreur d'info écrit dans la mémoire partagée.

et si au basculement on retombe sur le process consommateur, bah y va consommer quelque chose d'incomplet.

c'est un peu pareil pour des threads, si tu as une table qui sert d'échange d'info entre le process et ses threads, fo faire gaffe au cas où tu aurais des basculement de tâche pendant des modifications de la table d'échange.

antsite

Je me souviens

Ok, je vois, moi j'utilise Critical Section avec les threads, c'est pareil pour Shm ?

Taz

bisounours-codeur

oui, mais c'est carrément plsu chiant

Publicité

Page : 1 2

Page Suivante

Page Précédente

Haut de page

FORUM HardWare.fr

Programmation

C++

[C/C++] Dialoguer avec un processus fils

Sujets relatifs
[Unix] signaux et processus	[C] Timeout dans un processus ?
TCP-IP Pb recv bloquant et terminaison de processus	synchronisation de processus
Recherche de l'arrière petit fils	[VC++]Etat d'un processus Windows (Service)
Comment implémenter un processus persistant sur un serveur web?	L'exemple avec les boites reliees par des fils ?
[XSLT] les balises <xsl:param name="param1"> dans 1 processus XSLT	lancer un processus sous win ?
Plus de sujets relatifs à : [C/C++] Dialoguer avec un processus fils

Page générée en 0.135 secondes