Discussion :

[tooney]

Salut à tous,

Voilà je m'initie à la programmation système, et je suis en train d'essayer de comprendre le programme suivant... Ca doit pas être bien compliqué mais bon.
Alors si quelqu'un peut m'apporter ses lumières :

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
 
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
 
int main(void) {
	int f1,f2,w1,w2,r1,r2,r3;
	float calcul;
 
	f1 = fork();
	if (f1 == 0) {
		int res;
		res = 1+5;
		printf("Fils1 : calcul terminé.\n");
		exit(res);
		}
	f2 = fork();
	if (f2 == 0) {
		int res;
		res = 6-2;
		printf("Fils2 : calcul terminé.\n");
		exit(res);
		}
	w1 = wait(&r1);
	w2 = wait(&r2);
	r1 = WEXITSTATUS(r1);
	r2 = WEXITSTATUS(r2); 
	if (w1 != f1) {
		r3=r1;
		r1=r2;
		r2=r3;
		}
	r3 = 8 + 6;
	calcul = (float)(r1 * (r2+1)) / (float)r3;
	printf("Résultat du calcul : %f\n", calcul);
	}

Bon jusque

Code :

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

f1 = fork();

tout va bien. On crée un processus fils héritant des variables de son père, à savoir f1, f2,....

Avec

Code :

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

if (f1 == 0) {

, on rentre dans le processus fils, et on lui alloue une variable res. Par contre ce qui me pose problème, c'est l'instruction exit(res); combiné à l'instruction wait(&r1);

Là je suis un peu perdu et je ne vois pas ce que font ces instructions... Je sais que wait() sert à attendre la mort du fils, mais à quoi correspond le paramètre &r1?

Merci de m'aider!!!![/code]

[LordBob]

alors en fait le programme, va lancer 2 processus, c'est comme s'il se dupliquer en quelque sorte, c'est une copie de lui meme qui s'execute à partir du fork.

donc en fait quand tu fait un fork(), ca lance le meme programme, qui contient les meme variables et qui commence à l'endroit ou à était fait le fork dans le processus pere. ensuite on fait (f1 == 0) pour savoir si c'est le fils qui s'execute, et on lui fait faire le calcul 1+5 que l'on range dans la variable res. ensuite on termine le processus fils1 en lui faisant retourné res donc 6.

de meme pour le deuxieme fork() qui lance un deuxieme processus fils qui fait 6-2 et le range dans res. a ce moment la, c'est comme si tu avais 3 programme lancé, mais qui fesait des choses différentes.

le pere lui continue son execution sans entré dans les if. il attend ensuite je ne suis pas sur de savoir à quoi correspond le wait, mais ensuite r1 et r2 récupére la valeur de sortie des processus f1 et f2 (celle du 'exit(res)')
ensuite le processus pere fait un calcul avec le resultat des deux autres processus plus un calcul qu'il a fait apres et affiche le resultat.

bon je suis conscient que tout ne va pas te sembler clair, mais tu peux me demander d'éclaircir certain points, vu que je sais que j'explique un mal

[Skyounet]

Alors que je dise pas de betises.

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 <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
 
int main(void) {
   int f1,f2,w1,w2,r1,r2,r3; //declaration de variables
   float calcul;  //declaration de variables
 
   f1 = fork(); // fork permet de creer un nouveau processus qui s'execute de maniere concurrente avec le processus qui l'a creer
   if (f1 == 0) { // f1 vaut 0 chez le fils qui a ete creer et vaut le pid du fils creer chez le pere, ici si f1 == 0 ca veu dire qu'on se trouve chez le fils
      int res;
      res = 1+5; // res = 6
      printf("Fils1 : calcul terminé.\n");
      exit(res); // le fils se termine en renvoi res cad 6
      }
   f2 = fork(); // idem que pour l'autre
   if (f2 == 0) {
      int res;
      res = 6-2; // res = 4
      printf("Fils2 : calcul terminé.\n");
      exit(res); // le fils se termine et renvoi res cad 4
      }
   printf("%x\n",&r1); // affiche l'adresse de la variable r1
   w1 = wait(&r1); // le pere recupere la mort de son fils
   printf("%i\n",w1); // affiche la valeur de w1 cad le pid du fils mort
   w2 = wait(&r2); // le pere recupere la mort de son fils
   printf("%i\n",w2); // affiche la valeur de w2 cad le pid du fils mort
   r1 = WEXITSTATUS(r1); // donne le code de retour tel qu'il a été mentionné dans l'appel exit() du fils cad res
   r2 = WEXITSTATUS(r2); // donne le code de retour tel qu'il a été mentionné dans l'appel exit() du fils cad res
   if (w1 != f1) // si w1 cad le pid du fils mort en premier different de f1 cad le pid du fils1
      r3=r1; // r3 = 4
      r1=r2; // r1 = 6
      r2=r3; // r2 = 4
      }
   r3 = 8 + 6;  // r3 = 14
   calcul = (float)(r1 * (r2+1)) / (float)r3;  // simple calcul
   printf("Résultat du calcul : %f\n", calcul);  // affiche le resultat du calcul
   }

Merci de me signaler toute erreur de ma part
Merci

[tooney]

Ah OK je crois comprendre!!!!

En fait wait est bien combiné à exit.

Comme je le disais, wait() est l'instruction qui sert effectivement au père à attendre la mort de son fils. Donc le 1er wait attend la terminaison du premier processus, et range la variable de sortie (res) à l'adresse de r1 (&r1).
Même chose pour le deuxième processus.

On récupère ensuite les résultats des calculs des deux processus fils en appelant la fonction WEXISTATUS poru savoir ce qui est rangé au niveau de r1 (les deux résultats res des calculs), et l'attribuer respectivement à r1 et r2.

Alors par contre après je suis un peu perdu avec le test if(w1!=f1).
Est-ce que ce ne serait pas pour inverser les variables dans le cas où le 2ème processus fils finirait avant le 1er??? Car je crois que l'instruction w1 = wait(&r1) renvoie le PID du 1er processus qui finit non?

[tooney]

Autant pour moi si je me suis trompé de forum, mais c'est vrai que c'est de la programmation de systèmes d'exploitation orienté plutôt sur UNIX....

Pas de problème si je dois être redirigé...

[Skyounet]

w1 = wait(&r1)

Oui tout a fait.
Tu a raison c'est surement pour echanger les variables pour qu'elles soient comme si c'etait le fils qui aurait terminé en premier.

Par contre pour le wait(&r1); je suis pas sur que r1 recoivent le code de sortie du fils c'est le travail du WEXITSTATUS
Je crois que r1 recupere le "status" du fils pour apres l'utiliser pour recuperer le code de sortie via WEXITSTATUS.

[tooney]

Merci Skyrunner et LordBob, je crois qu'on a compris en même temps... Evidemment il a suffi que je poste pour réfléchir 5 minutes....

Bon la prochaine fois ça me servira de leçon... en tout cas j'espère que ça aura pu servir à d'autres!!!

[Emmanuel Delahaye]

Autant pour moi si je me suis trompé de forum, mais c'est vrai que c'est de la programmation de systèmes d'exploitation orienté plutôt sur UNIX...

Ce n'est pas de la programmation de système. C'est de la programmation d'application sur un système donné. La programmation système, c'est, par exemple, ajouter un module (driver) au système Linux.