[Debutant] Tubes non nommés, fork et crible d'Ératosthène
Bonjour à tous,
En révisant mon examen de système, je suis tombé sur le programme suivant qui sert a renvoyer les nombres premiers entre 2 et n (une borne supérieure passé en paramètre).
En revanche, j'ai du mal a comprendre son fonctionnement, une aide serait vraiment la bienvenue... :oops:
(j'ai mis que le principal, exit certains tests et messages d'erreurs correspondants)
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
| int main(int argc, char** argv) {
int borne = atoi(argv[1]);
int tube[2];
pid_t fils;
pipe(tube);
switch (fils = fork()) {
case 0:
crible(tube);
exit(0);
break;
default:
close(tube[0]);
for (int i=2 ; i<=borne ; i++) {
write(tube[1], (void*)&i, sizeof(int));
}
close(tube[1]);
wait(0);
return 0;
break;
}
} |
Donc d'après ce que je comprends (arrêtez moi si je me trompe), dans le main, on crée un processus fils et on envoi a ce dernier tous les nombres compris entre 2 et la borne supérieure (le argv[1] passé).
J'ai 2 questions:
- Pourquoi ferme-on la sortie du tube quand on est dans le processus père?
- Pourquoi caste-on l'entier i en void*?
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
| void crible(int *in) {
int P;
read(in[0], (void*)&P, sizeof(int));
printf("%d", P);
int out[2];
pipe(out);
pid_t fils;
fils = fork();
switch (fils) {
case 0:
close(in[0]);
crible(out);
exit(0);
break;
default:
close(out[0]);
int i;
while (read(in[0], (void*) &i, sizeof(int)) == sizeof(int)) {
if (i % P) {
write(out[1], (void*) &i, sizeof(int));
}
}
close(in[0]);
close(out[1]);
return;
break;
}
} |
Et c'est la que ca se corse pour moi... Ce que j'ai compris (ou du moins ce que je pense avoir compris):
- La fonction crible recoit un tube, et lit le premier nombre (P) en entrée et l'affiche. (file?)
- Création d'un second tube et d'un processus fils
- Si on est dans le processus père, on lit les nombres présents (i) dans le tube passé en paramètre, si i%P != 0 alors on conserve le i et on l'écrit dans le second tube
- Si on est dans le fils, on rappelle la fonction avec le second tube => récursivité: a chaque passage on élimine les nombres divisibles par P
Même questions que ci dessus? Pourquoi ces (void*) et ces closes?
Autre question: un tube fonctionne comme une file?
Quand je fais :
Code:
read(in[0], (void*)&P, sizeof(int));
Elle "défile" le premier, et le tube conserve tous les autres nombres?
Merci a ceux qui m'ont lu.
Et un grand merci à ceux qui relèveront mes erreurs, et répondront a mes questions. ;)
Bonne soirée.
