Discussion :

[Tuxico]

bonjour à tous,

alors voilà cela fait plusieurs heures que j'essaye de réaliser une arborescence de processus en C avec fork(),wait() etc

L'arborescence doit etre la suivante :

Code :

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

1
2
3
4
5
6
 
                                   P1
                                  /   \
                                P2     P3
                                 |    /  \
                                P4     P5   P6

J'ai bien sur lu le manuel de fork(), des tutos divers mais plusieurs me problèmes me viennent ...

tout d'abbord : Si je crée un processus P1, je vérifie son pid, si c'est le père je ne fais rien, si c'est le fils je recrée un processus P2
Hors je m'attends à donc avoir 3 processus, mais la création de forks étant exponenitelle je m'en retrouve avec 4 donc 2 clones...et je ne comprends pas comment palier ce problème?

En gros, comment organiser la création de processus père->multi-fils et comment gerer la creation exponentielle de ceux-ci?

je rajouteque ca ne sert a rien de m'envoyer vers google c'est fait, les seuls exemples sont un pere, un fils .

merci

[granquet]

tout d'abbord : Si je crée un processus P1, je vérifie son pid, si c'est le père je ne fais rien, si c'est le fils je recrée un processus P2

euh? soit tu t'exprime mal, soit j'ai du mal a saisir.

pour realiser ce que tu veux faire:
Processus P1 cree un Fils P1-F1
Si c'est P1, on cree un autre Fils P1-F2

Si c'est P1-F2, on cree un Fils P1-F2-F1

Si c'est P1-F2-F1, on s'arrete
Si c'est P1-F2 on cree un nouveau processus Fils P1-F2-F2

Si c'est P-F1, on cree un Fils P1-F1-F1

on as finit pour la branche gauche

---
en fait je me relis ... et je m'apperçois que c'est tetre pas tres clair
si ça t'aide ... tant mieux ... sinon tant pis

[Tuxico]

non c'est très clair, merci c'est le principe que je voulais appliquer mais en fait je voulais éviter d'embriquer des if-else .
Donc en gros de jouer avec un for car pour cet algo, les "if" ne sont pas encore trop nombreux mais j'ai le meme genre, où l'utilisateur entre le nombre de "branches" entre 1 et 100

[Tuxico]

je viens de tester mais j'ai toujours ce problème de clone :

Je suis P1, mon numero est le : 5237, mon pere est le : 5236
Je suis P1, mon numero est le : 5236, mon pere est le : 5160
Je suis P2, mon numero est le : 5238, mon pere est le : 5236
Je suis P2, mon numero est le : 5236, mon pere est le : 5160

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include <stdio.h>
#include <sys/types.h>
 
/*
Ce programme genere l'arborescence de processus suivante :
 
   P2-P4
  /
P1    P5
  \  /
   P3 
     \
      P6
*/
 
int main(void)
{
  pid_t P1 = fork();
  int P1_pid = getpid();
  int P1_parent = getppid();
  printf("Je suis P1, mon numero est le : %d, mon pere est le : %d\n",P1_pid,P1_parent);
  wait(0);
 
  if(P1 == 0)
  {
  /* Child */
  }
  else
  {
  /* Father */
    pid_t P2 = fork();
    int P2_pid = getpid();
    int P2_parent = getppid();
    printf("Je suis P2, mon numero est le : %d, mon pere est le : %d\n",P2_pid,P2_parent);
  }
 
 
return 0;
}

voici juste le début de l'arboresence, j'attends 2 processus, un pere et un fils et je recois a chaque fois pere-fils, pere-fils...

est-ce que j'ai tout mal compris?

[Gruik]

Putain j'ai eu cet exo au partiel de systeme...

[granquet]

Je suis P1, mon numero est le : 5236, mon pere est le : 5160

5160 ne serait pas le pid de ton shell bash par hasard?

et t'as oublié
#include <unistd.h>
#include <sys/wait.h>

---edit---
apres essais:

ebola@gentoo ~/src $ ./fork-tuxico
Je suis P1, mon numero est le : 14248, mon pere est le : 14247
Je suis P1, mon numero est le : 14247, mon pere est le : 8850
Je suis P2, mon numero est le : 14249, mon pere est le : 14247
Je suis P2, mon numero est le : 14247, mon pere est le : 8850

8850 pts/1 00:00:00 bash

-

Putain j'ai eu cet exo au partiel de systeme...

t'as eu 20 j'espere

[MatRem]

A mon avis, dans ton exo P1 corespond au processus cree par l'execution de ton programme, le processus principal.


Ensuite quand tu fais ça:

Code :

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

1
2
3
4
pid_t P1 = fork(); //ligne 0
int P1_pid = getpid(); //ligne 1
int P1_parent = getppid(); //ligne 3
printf("Je suis P1, mon numero est le : %d, mon pere est le : %d\n",P1_pid,P1_parent);//ligne 4

Avant la ligne 0 tu n'as qu'un processus, le processus principal.
Ensuite à la ligne 0 tu cree un nouveau processus (P1).
Donc P1 commence à vivre aprés le fork et il va executer les lignes 1,2,3,4.
Cependant le pere continue a vivre aussi apres le fork donc le processus principal va aussi executer les ligne 1,2,3,4.

Ce qui fait que le proccessus principal va recuperer son pid ainsi que le pid de son pere (sans doute le pid du shell). Puis il affichera le message.
Le processus P1 va faire la même chose. Le pid de son pere sera egal au pid du processus principal puisque qu'il est créé par lui.

Si tu veux pas avoir ce comportement, et avoir le message que dans le fils, il faut qu'il soit dans le if(pid==0){...}.

Voilà je sais pas si j'ai été clair, j'espère que ça t'es utile

[MatRem]

Voilà un exemple pour creer la branche de gauche:

Attention pour un cas complet il faut absolument tester le retour des appels systèmes (fork et wait), pour savoir si il n'y a pas d'erreur, et s'il y en a agir en conséquences.

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
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
 
int main()
{
	//Processus p1
	pid_t pid;
 
	printf("processus 1 (principal) (pid:%i)\n", getpid());
 
	pid = fork();
 
	if(pid==0) //Processus p2
	{
		printf("processus 2 (pid:%i - ppid:%i)\n", getpid(), getppid());
 
		pid = fork(); //pid different de pid précédent (de p1) (pas de risque de collision)
 
		if(pid==0) //Processus p4
		{
			printf("processus 4 (pid:%i - ppid:%i)\n", getpid(), getppid());
		}
		else //Processus p2
		{
			printf("processus 2(%i) apres la creation de p4(%i)\n", getpid(), pid);
		}
	}
	else
	{
		//Processus p1
		printf("processus 1(%i) apres la creation de p2(%i)\n", getpid(), pid);
		while (wait(NULL)!=-1);
	}
 
	//Ici tous les processus passent
	printf("Fin (%i)\n", getpid());
 
	return EXIT_SUCCESS;
}

Voici un exemple de résultat:

processus 1 (principal) (pid:13199)
processus 2 (pid:13200 - ppid:13199)
processus 4 (pid:13201 - ppid:13200)
Fin (13201)
processus 2(13200) apres la creation de p4(13201)
Fin (13200)
processus 1(13199) apres la creation de p2(13200)
Fin (13199)

Remarque
il se peut que
"processus 2(13200) apres la creation de p4(13201)" apparaisse avant
processus 4 (pid:13201 - ppid:13200)

En effet c'est le systeme d'exploitation qui gere l'ordonnancement des processus, il est donc a priori impossible de savoir si le message de p4 sera executé avant le dexieme message de p2.

[Tuxico]

un grand merci, je n'en demandais pas tant

En effet, le processus P1 devait le programme en lui-même et non pas le bash

Tout ceci m'à permis de comprendre mes autres exos sans problèmes (pas bien compliqués en soi en fait...mais bon faut passer par là d'abord )

merci à tous .

[Grizli]

Bonjour,
Je voudrai savoir comment je pourrai faire pour crées un lien de parenté entre 1 processus père et N processus fils.

Le problème que je rencontre a chaque fois c'est lors du fork() le corp d'exécution se duplique et j'ai des soucis avec la boucle for qui générer les processus.

Merci de me mettre sur les rails pour que je puisse avancer.

Code :

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

1
2
3
4
5
 
P0
|_____________________________________
|      |       |       |       |    ....    |
P1   P2   P3    P4    P..         Pn

Ouali.A