communication entre processus dans quel cas

**gastoncs** · 04/05/2012, 21h41

Bonsoir,

je m'essaye a la communication entre processus, pour ce faire jai crée un programme en C avec une fonction qui crée un processus pour une fonction passé en paramétre, a l'aide de ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int nouveau_processus( void (*nouv_prog)()){
pid_t processus;
processus = fork();
 
if (processus == -1){
printf("erreur dans la création du processus\n");
return 0;
}
else if (processus == 0){
printf("je suis dans le processus fils et j'execute la fonction en paramétre\n");
nouv_prog();
return getpid();
}
}

j'ai une fonction change état LED qui change l'état d'un variable, et une fonction [I]voir etat LED[I] qui me renvoi l'état de la variable, voici le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int LED = 0;
 
void change_etat_LED(int b){
LED = b;
}
 
int voir_etat_LED(){
return LED;
}

ainsi pour crée un nouveau processus avec ces fonctions je fait ceci :

Code :

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

1
2
3
4
5
6
7
 
void nouveau_programme1(){
change_etat_LED(3);
}
 
//je crée le processus avec mon nouveau_programme1
nouveau_processus(nouveau_programme1);

maintenant si je souhaite voir le changemement d'état de ma variable je crée un nouveau processus de cette facon :

Code :

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

1
2
3
4
5
6
void nouveau_programme2(){
voir_etat_LED()
}
 
//je crée le processus avec mon nouveau_programme2
nouveau_processus(nouveau_programme2);

Le problème c'est que tout ça fonctionne, la variable LED et bien changer pas 'nouveau_programme1' et moi ce que je voudrais c'est faire communiquer l'état de la variable LED par un système de communication inter processus IPC (du genre MSQ ou autres), est ce que j'ai loupé quelques chose ?

**Obsidian** · 04/05/2012, 22h48

Bonjour,

Lorsque tu fais fork(), tu crées un nouveau programme totalement indépendant, à partir du premier. Ils disposent donc chacun de leur propre espace mémoire. Même si juste après le fork(), celui du fils est la copie conforme de celui du père, ils vivent désormais leur vie chacun de leur côté.

Pour faire ce que tu veux faire, tu as deux solutions :

Tu utilises effectivement un mécanisme de communication inter-processus, lesquels sont en substance formés par : les tubes, les sockets, les signaux (dans une certaine mesure, attention), les fichiers (pareillement), le mapping de fichiers et les IPC SysV dont files de messages, sémaphores et segments de mémoire partagée. Tous ces mécanismes nécessitent une participation active des deux processus ;
Tu crées des threads : dans ce cas, les deux processus dits « légers » partagent en permanence le même espace mémoire. Mais attention : pas la même pile. Donc, il faut composer avec des phénomènes tels que le TLS.

**gastoncs** · 04/05/2012, 22h55

ok mais alors dans mon cas j'ai pourtant crée deux processus fils exécutant chacun une fonction, et je n'ai pas eu besoin d'IPC pour récupérer la valeur de ma variable LED !
comment cela ce fait il ?

**Obsidian** · 04/05/2012, 23h00

Parce que chaque processus dispose de sa propre copie de ta variable LED et c'est la copie locale qui est lue à chaque fois.

Par ailleurs, si c'est le père qui change l'état de la variable et qui — ensuite — crée un deuxième fils pour en afficher l'état, alors ce deuxième fils héritera d'une copie de la variable déjà modifiée.

**gastoncs** · 04/05/2012, 23h07

donc dans ce cas je n'ai pas besoin d'IPC ?

**Obsidian** · 04/05/2012, 23h24

Si.

Ce que je suis en train de dire, c'est que tu penses avoir modifié la variable d'un autre processus mais qu'il ne s'agit en fait que d'une illusion.

**gastoncs** · 05/05/2012, 13h54

alors comment pourrais je faire pour implémenter l'IPC ?
pour que lorsque j'affiche l'état de ma variable précédemment changé par un processus fils et non la copie locale qui est lue à chaque fois !
(je ne sais pas si ma question est clair

)

**Obsidian** · 05/05/2012, 14h47

Relis mon commentaire #2.

**gastoncs** · 05/05/2012, 22h29

j'ai vraiment du mal à saisir !

désolé
mais donc ce que je veux faire ne fonctionne pas, je ne peux pas communiquer les variables modifier par les fonctions a la création de nouveaux fils, si j'ai bien compris il faut que je passe par le pére ?

**Obsidian** · 05/05/2012, 23h03

Non. De deux choses l'une :

— Soit tu as deux processus bien distincts l'un de l'autre (par exemple deux applications différentes) et, dans ce cas, il faut mettre en place un mécanisme utilisé activement par chacun des processus : par exemple un tube. Dans ce cas précis, l'un des processus écrit dedans en appelant write() et l'autre lit ce qui en sort avec read(). Il y a d'autres manières de communiquer entre deux processus, et elles ont toutes leurs spécificités.

— Soit tu utilises deux threads, qui semblent être ce que tu cherches à faire : dans ce cas, tes deux processus font tourner le même programme et, donc, peuvent partager le même espace mémoire. Dans ce cas, les modifications appliquées à une variable seront visibles par tous les threads puisqu'il s'agit de la même variable. Attention toutefois : ce n'est vrai qu'avec les variables globales (généralement proscrites) et l'espace alloué avec malloc().

Il existe également une solution intermédiaire : demander un système de créer un segment de mémoire partagée. Tout processus peut alors soit en hériter, soit demander à s'y rattacher explicitement. Dans ce cas, les processus restent très différents les uns des autres et sont aussi cloisonnés, mais tout ce qui est écrit dans ce segment en particulier sera automatiquement visible par tous les processus qui s'y sont rattachés.

**gastoncs** · 06/05/2012, 14h35

NdlM : discussion fusionnée avec la précédente.

Bonjour j'ai fait un petit programme pour m’entraîner au fork()
En fait c'est une fonction 'nouveau_programme' qui prend en paramètre une fonction (qui change l'état d'une variable) et crée un processus pour la fonction passé en paramètre, la voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//crée un processus pour un nouveau programme
int v2_nouveau_programme(void (*nouv_prog)()){
 
pid_t processus;
processus = fork();
 
if (processus == -1) { // erreur
	printf("erreur dans la creation du processus"); 
	return 0;
}
 
else if (processus == 0) { //processus fils
	nbr_simultane++;
	printf("processus fils de pid %d et de pére%d\n",getpid(), getppid()); 
	nouv_prog();
	return 4;
 
}
}

et j'ai une fonction par exemple, 'rotate_bras_gauche'

Code :

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

1
2
3
4
 
void rotate_bras_gauche(int a){
	bras_gauche = a;	
}

Donc pour exécuter la fonction ci dessus dans un nouveau processus, je fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int bras_gauche =0;
 
void mon_programme_1()
{
	rotate_bras_gauche(90);
}
 
//crée un processus pour la rotation du bras 
int main(){
v2_nouveau_programme(mon_programme_1);
sleep(5);
printf("valeur de bras_gauche :%d\n", bras_gauche);
return 0;
}

Mon soucis est que après l’exécution de 'v2_nouveau_programme(mon_programme_1)' ma variable bras_gauche à bien changé de valeur ! elle est a 90, alors que je fait la modification dans un nouveau processus !
N'aurais je pas du utilise un système de tubes nommées ou autre , comment ce fait il que ça fonctionne ? (a cause du copy on write ???)
j'ai crée un post précédent sur le même sujet mais celui ci s'accompagne d'un exemple

merci

**Sve@r** · 06/05/2012, 15h28

Envoyé par gastoncs

Bonjour j'ai fait un petit programme pour m’entraîner au fork()
En fait c'est une fonction 'nouveau_programme' qui prend en paramètre une fonction (qui change l'état d'une variable) et crée un processus pour la fonction passé en paramètre, la voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//crée un processus pour un nouveau programme
int v2_nouveau_programme(void (*nouv_prog)()){
 
pid_t processus;
processus = fork();
 
if (processus == -1) { // erreur
	printf("erreur dans la creation du processus"); 
	return 0;
}
 
else if (processus == 0) { //processus fils
	nbr_simultane++;
	printf("processus fils de pid %d et de pére%d\n",getpid(), getppid()); 
	nouv_prog();
	return 4;
 
}
}

et j'ai une fonction par exemple, 'rotate_bras_gauche'

Code :

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

1
2
3
4
 
void rotate_bras_gauche(int a){
	bras_gauche = a;	
}

Donc pour exécuter la fonction ci dessus dans un nouveau processus, je fais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int bras_gauche =0;
 
void mon_programme_1()
{
	rotate_bras_gauche(90);
}
 
//crée un processus pour la rotation du bras 
int main(){
v2_nouveau_programme(mon_programme_1);
sleep(5);
printf("valeur de bras_gauche :%d\n", bras_gauche);
return 0;
}

Mon soucis est que après l’exécution de 'v2_nouveau_programme(mon_programme_1)' ma variable bras_gauche à bien changé de valeur ! elle est a 90, alors que je fait la modification dans un nouveau processus !

Ben oui, et c'est le nouveau processus fils qui affiche sa variable bras_gauche pendant que le père, lui-aussi, affiche la sienne...

Code :

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

1
2
3
4
5
6
moi@debian:~$ make a
cc     a.c   -o a
moi@debian:~$ ./a
processus fils de pid 1810 et de pére1809
valeur de bras_gauche :0
moi@debian:~$ valeur de bras_gauche :90

Envoyé par gastoncs

N'aurais je pas du utilise un système de tubes nommées ou autre , comment ce fait il que ça fonctionne ? (a cause du copy on write ???)

Comment se fait-il que "quoi" fonctionne ??? Qu'est-ce que tu appelles "fonctionner" ???
Le pipe est juste un des outils qui te permettra de transférer des valeurs d'un processus à un autre, rien de plus.

Envoyé par gastoncs

j'ai crée un post précédent sur le même sujet mais celui ci s'accompagne d'un exemple

Et il ne t'est pas venu à l'idée de compléter ton post précédent ???

**gastoncs** · 08/05/2012, 23h18

et bien je me demande comment faire pour modifier aussi la variable bras_gauche du père ?

**Obsidian** · 08/05/2012, 23h34

Envoyé par gastoncs

et bien je me demande comment faire pour modifier aussi la variable bras_gauche du père ?

On te l'a déjà expliqué : relis les commentaires #2 et #10.

Quand tu appelles fork(), tu crées un nouveau programme. Il est alors complètement indépendant du premier, même s'il en est la copie conforme et que leur déroulement se poursuit à partir du même point. Le processus fils n'a plus aucune vue sur la mémoire du processus père.

Donc, pour faire ce que tu veux faire :

— Soit tu crées un thread ;
— Soit tu crées un segment de mémoire partagée et tu places les variables à modifier dedans ;
— Soit tu mets en place un mécanisme de communication, comme un tube, et les deux parties doivent l'exploiter. Ce sont ensuite chacune des deux parties qui modifieront leur propre variable, chacune de leur côté, en fonction de ce qu'elles auront lu.

Jette un œil aux posixthreads, qui ont l'air de correspondre le mieux à ce que tu essaies de faire : ils créent non seulement un processus léger dans le même espace mémoire que le père, mais il le font en appelant directement la fonction que tu as passée en paramètre.

**gastoncs** · 09/05/2012, 00h03

désolé j'avais du mal a comprendre !!
mais je vais m'orienter vers les threads, je pense que ce sera plus adapté comme tu dis.
désolé encore

communication entre processus dans quel cas

C

Discussions similaires

Partager

Partager