Fork() Gestion process

Version imprimable

Bonjour à tous,

Voilà L'objectif est de crée 10 génération de processus.
Le processus père crée un fils, qui lui même crée un fils, qui lui même crée un fils, . . . . Et cela 10 fois.

Voilà ce que j'ai actuellement

Code:

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
 
#include <stdio.h>
#include <unistd.h>
 
int main(){
int pid;
int pidd;
int status;
int i;
       switch(pid=fork()){
            case -1: printf("Error lors de la création du proc fils");
                        exit(0);
            case 0: printf("Je suis le premier fils %d  de pere %d\n", getpid(), getppid());
                        i = 0;
                        do{
                        pidd = fork();
                        switch(pidd){
                        case -1:
                               printf("Error");
                               exit(0);
                        case 0: 
                               printf("Je suis le fils n°%d , %d de pere %d\n", i, getpid(), getppid();
                               exit(0);
 
                        default:
                               wait(NULL);
                               printf("Je suis le père\n");
                        }
                        i++;
                        }while(i <10);
                        printf("Je sors de ma boucle\n");
                        exit(0);
             default: wait(&status);
                        printf("Je suis le premier père\n");
                        printf("Je suis le premier fils %d de pere %d\n", getpid(), getppid());
                        exit(128);         
         }
         return 0;
}

Et voilà ce que j'ai en console :
http://imageshack.com/a/img841/5087/hgld.png

Je ne comprend pas pourquoi c'est toujours le même processus qui crée les différent fils.
J'ai fait à coter un autre traitement avec juste des switch case imbriquer les un dans les autres. Cela fonctionne bien, j'ai bien 10 génération.

Merci d'avance pour votre aide.

28/11/2013, 23h12
Neckara

Bonjour,

IUT d'Auvergne ? (ça me rappelle un des exercice^^)

Citation:

Je ne comprend pas pourquoi c'est toujours le même processus qui crée les différent fils.

Est-ce bien toi qui a écrit le code ?
Parce que tu fais un exit(0); si c'est un fils, ce n'est donc pas étonnant qu'ils ne puissent pas créer des fils :aie:
29/11/2013, 09h32
Médinoc

~~Heureusement d'ailleurs, sinon ça ferait une fork bomb.~~

Euh...
Je sais pas mais pour moi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int main(void) { pid_t pid; int i = 0; while (i < 10) { pid = fork(); if (pid == 0) i++; else return (0); } return (0); }
Ca ne ressemble pas vraiment à une fork bomb...
[Désolé pour la réponse au passage ?]

29/11/2013, 10h03
Sve@r
Citation:

Envoyé par Dark_fun

Je ne comprend pas pourquoi c'est toujours le même processus qui crée les différent fils.

Salut
Ton premier fils instancie une boucle do ... while et génère un nouveau fils dans cette boucle. Donc c'est normal que ce soit cet unique premier fils qui soit le père des 10 autres.
De son coté, le père meurt juste après donc il ne peut rien générer d'autre. Et chaque petits-fils meurt aussi juste à sa création donc eux non-plus ne peuvent pas utiliser le do...while de cet unique premier fils.
Citation:
Envoyé par Metalman

Euh...
Je sais pas mais pour moi :

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int main(void) { pid_t pid; int i = 0; while (i < 10) { pid = fork(); if (pid == 0) i++; else return (0); } return (0); }

Ca ne ressemble pas vraiment à une fork bomb...
Ben non, tu as pensé à mettre des "return" pour bloquer. Medinoc parlait d'un code sans exit (ni de return s'y substituant)...
29/11/2013, 10h04
Médinoc

Tu as raison, quand c'est bien fait ça n'a pas l'air d'avoir ce genre de problème.

C'est juste que ça me fait bizarre de voir une boucle pour une chose censée s'effectuer une seule fois par processus (fork() complique vraiment les choses).
29/11/2013, 10h17
Metalman

C'est comme pour le récursif : condition d'arrêt/sortie à mettre au plus vite.

Mais j'admets qu'à débugger c'est beaucoup plus risqué "fork()" que du récursif...

Franchement, dans le cas présent je considérerais une implémentation récursive comme plus claire:

Code:

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
int forkex(int (*sonFunc)(intptr_t), intptr_t sonData)
{
	int ret = fork();
	if(ret == 0)
	{
		int sonRet = sonFunc(sonData);
		exit(sonRet);
	}
	return ret;
}
 
int SonFunction(intptr_t mydata)
{
	int nbSonsCreated = (int)mydata;
	nbSonsCreated++; /*count myself*/
 
	if(nbSonsCreated < 10)
		forkex(SonFunction, (intptr_t)nbSonsCreated);
}
 
int main(void)
{
	int nbSonsCreated = 0;
	forkex(SonFunction, (intptr_t)nbSonsCreated);
	return 0;
}