Discussion :

[felix01]

Bonsoir
j'ai besoin d'une petite explication de code c suivant

Code :

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

1
2
3
4
5
6
7
8
9
#include <unistd.h>
int main(){
    if (fork())
        (fork() || ( fork()) && fork() )) && fork() ;
    else
        fork();
    ;
    return 0;
}

normalement le programme crée 6 processus lié entre eux par une arbre mais je vois pas comment ça se fait avec ce bout de code
Merci

[MarieKisSlaJoue]

Bah la fonction fork() scinde la processus en 2.
L'appelle à cette fonction ce fait 6 fois. tu as donc 6 processus qui vienne du premier.

Par contre c'est l’intérêt du code moi que j'aimerai bien qu'on m'explique...

[kwariz]

Bonsoir,

Il y a un problème de parenthèses me semble-t-il.

Pour répondre à ta question il faut savoir que fork() clone le processus, dans le processus fils la valeur de retour est 0 (donc FALSE si tu la considères comme un booléen), alors que dans le père la valeur de retour est un entier positif, le PID du processus fils (donc TRUE si tu la considères comme un booléen).

Il faut aussi savoir que les opérateurs && et || ont un comportement particulier. En ce qui concerne &&, si la première opérande (celle de gauche) est fausse (donc un entier nul) alors la seconde opérande n'est pas évaluée. Respectivement pour || si la première opérande (toujours celle de gauche) est vraie (donc un entier non nul) alors la seconde opérande n'est pas évaluée. && a une précédence supérieure à || (un peu comme * a une précédence supérieure à +).

Normalement avec toutes ces informations tu peux construire une trace de ton programme et en déduire une arbre de processus.

Une dernière remarque, il se peut que le fork() échoue ... dans ce cas la valeur renvoyée est -1 et aucun processus fils n'est créé. Certainement un cas à étudier.

[Obsidian]

normalement le programme crée 6 processus lié entre eux par une arbre mais je vois pas comment ça se fait avec ce bout de code
Merci

Il y a encore une chose à ajouter : si tu lances ton programme en l'état, tu ne verras jamais tes processus car tous ceux-ci prendront fin avant même que tu aies l'occasion de les examiner et, à dire vrai, il est probable que certains d'entre eux arrivent à échéance avant même que les derniers fork() soient accomplis.

Bah la fonction fork() scinde la processus en 2.
L'appelle à cette fonction ce fait 6 fois. tu as donc 6 processus qui vienne du premier.

Ce n'est pas suffisant : il faut que tous les fork() soient liés entre eux avec une condition if else (ou des && et ||) écrite avec soin. Sinon, le père et le fils vont tous deux créer un nouveau processus chacun quand ils rencontreront le fork() suivant. Par exemple, le programme suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <unistd.h>
 
int main (void)
{
    /* Mitose */
    fork();
    fork();
    fork();
    fork();
 
    pause();
    return 0;
}

… produira seize processus en tout et pas quatre.

[felix01]

Pouvez vous m'expliquer s'il vous plait comment ça crée 16 processus car j'ai tenté de voir ça sur une arbre mais j'arrive pas merci

[kwariz]

Essaye de créer une fonction do_fork qui affiche le pid du processus qui fait le fork, fait un fork, et affiche les pid des processus et de leur parent après le fork.
C'est faire une trace du programme.
Ces affichages permettent de comprendre ce qui se passe.

[felix01]

Merci infiniment de vos réponses

[Obsidian]

Pouvez vous m'expliquer s'il vous plait comment ça crée 16 processus car j'ai tenté de voir ça sur une arbre mais j'arrive pas merci

Le conseil que t'as donné Kwariz est judicieux et ça t'apportera effectivement beaucoup de le suivre. Cela dit, je pense que c'est le fonctionnement même de fork() qui te manque. De lui découlera le reste naturellement.

« to fork » signifie « fourcher ». L'appel porte ce nom parce qu'il veut dire que ton fil d'exécution jusque là unique va se scinder en deux fils distincts qui, désormais, vont chacun vivre leur vie propre. En pratique, un nouveau processus va être créé à partir de l'original, mais ce dernier va continuer à exister (sinon, l'appel n'aurait aucun intérêt).

Ce qui est important, c'est qu'à l'issue de l'opération, le nouveau processus ne va pas démarrer un exécutable à partir du début mais va être le clone exact du processus initial. Il va hériter des mêmes variables avec les mêmes valeurs et surtout, l'exécution va se poursuivre dans chacun des fils à partir du même endroit. Autrement dit, tes processus vont tous deux sortir de fork().

En pratique, le système va considérer que le nouveau processus est le fils de celui qui a fait l'appel à fork(). Un « pstree » ou « ps auxf » sous Unix permet de t'en convaincre. Du côté des processus, c'est la valeur de retour de fork() qui va te permettre de savoir lequel des deux tu es :

• Si cette valeur est positive, tu es le père et la valeur en question est le PID de ton processus fils ;
• Si cette valeur est nulle, tu es le processus fils. Utilise getpid() pour connaître ton PID et getppid() pour obtenir celui du père ;
• Si cette valeur est négative, une erreur s'est produite et la création du processus fils a échoué (et tu es toujours le père, par conséquent).

À présent, il est assez simple de comprendre ce qui se passe dans le programme d'exemple : le processus exécute fork() et crée un clone de lui-même. L'un et l'autre sont donc tous deux sur le point d'exécuter le fork() suivant. Lorsque c'est fait, les deux processus ont à nouveau créé un clone de chacun d'eux et ont se retrouve à quatre. Au troisième fork(), huit processus, au quatrième : seize.