Discussion :

[Dark_fun]

Bonjour à tous,

Voilà L'objectif est de crée 10 génération de processus.
Le processus père crée un fils, qui lui même crée un fils, qui lui même crée un fils, . . . . Et cela 10 fois.

Voilà ce que j'ai actuellement

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
 
#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 :


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.

[Neckara]

Bonjour,

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

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

[Médinoc]

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

[Metalman]

Euh...
Je sais pas mais pour moi :

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 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 ?]

[Sve@r]

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.

Euh...
Je sais pas mais pour moi :

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 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)...

[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).

[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...

[Médinoc]

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

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
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;
}