Récursivité et fils en parallèle

Version imprimable

Bonjour,
je dois développer un programme qui exécute la copie de fichiers en parallèle (avec des processus fils et non des threads). Ca fonctionne couci-couca, étant donné que ce sont des relations père-fils, je ne peux pas utiliser de boucle mais une récursivité, si je ne me trompe pas?

Donc en gros, l'utilisateur lancera le programme: ./copie texte1.txt texte2.txt texte3.txt

Le premier fils s'occupe de la copie du fichier texte1.txt, le 2ème texte2.txt,...

Tous utilisent la fonction copie.
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 int traitement(int debut,int argc, char *argv[]){ int p = fork(); if (p == -1){ perror("Erreur de fork()"); } if (p == 0){ printf("%d %s\n",debut,argv[debut]); copie(argv[debut]); } else{ debut ++; if (debut < argc){ traitement(debut,argc,argv); } else{ return 0; } } return -1; //erreur } int main(int argc, char * argv[]){ if (argc <= 2){ perror("Entrez au moins un argument!"); } else{ if (traitement(1,argc,argv) ==0 ){ wait(0); } else{ perror("Erreur de traitement"); return -1; } } return 0; }
Les copies ont bien lieu mais je ne comprends pas bien le retour qu'il me fait:

Citation:

./ex2 texte.txt texte2.txt texte3.txt
1 texte.txt
2 texte2.txt
Erreur de traitement: Success
3 texte3.txt
Erreur de traitement: Success
Erreur de traitement: Success
Erreur de traitement: Success

Pourquoi revient-il dans le main tant qu'il n'a pas fini?

Merci d'avance :)

Edit: en fait j'ai compris, c'est le return -1 quand le fils s'exécute. Où pourrais-je mettre ce retour d'erreur ? Est-ce que ce code est acceptable?

19/03/2007, 09h34
Médinoc

Tu peux faire une boucle dans le père, pour le lancement de n processus fils.

PS: Précise "processus fils" car thread == fil. Résultat, quand tu dis "avec des fils et non des threads" il m'a fallu un moment pour comprendre...

Je peux difficilement faire une boucle car je veux que les processus fils s'exécutent en même temps. Pas de la programmation séquentielle.

Ici j'ai des processus fils en parallèles:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int pid1 = fork(); if (pid1 ==-1){ perror("Erreur de fork"); } if (pid1 ==0){ //fils 1 sleep(5); //vérification du parallélisme copie(argv[1]); exit(0); } else{ //pere int pid2 = fork(); if (pid2 ==-1){ perror("Erreur de fork"); } if (pid2 ==0){ //fils 2 sleep(5);//vérification du parallélisme copie(argv[2]); exit(0); } else{ //pere wait(0); } }
Avec le sleep(5), je peux vérifier que c'est bien en même temps que les processus fils s'exécutent.

Avec une boucle for (ou autre), j'aurai des processus fils qui s'exécuteront l'un après l'autre. (séquentielle)
Code:

1 2 3 4 5 6 7 for (i =1; i < argc; i++){ int p = fork(); if (p == -1){ perror("Erreur de fork()"); } copie(argv[i]); }
Donc je recherche le parallélisme sans savoir combien de fichiers je vais devoir traiter à l'avance, d'où l'idée d'une fonction récursive.

Encore merci pour votre aide

19/03/2007, 15h26
fearyourself

Citation:

Envoyé par v4np13

Bonjour,
Ca fonctionne couci-couca, étant donné que ce sont des relations père-fils, je ne peux pas utiliser de boucle mais une récursivité, si je ne me trompe pas?

Oui tu te trompes...

Code en cours...

Citation:

Edit: en fait j'ai compris, c'est le return -1 quand le fils s'exécute. Où pourrais-je mettre ce retour d'erreur ? Est-ce que ce code est acceptable?

Non il ne l'est pas car les fils retournent aussi dans le main et donc ca va un jour t'exploser à la figure ...

Jc
19/03/2007, 15h27
Ksempac

Je ne vois pas ce qui te fait dire que le for empeche la "parallelisation" de ton appli :

Exemple de comportement possible avec le for et n = 4 :

Le pere itere une fois -> Creation d'un fils
Le pere itere une fois -> Creation d'un fils
Le premier fils commence son execution
Le second fils commence son execution
Le pere itere une fois -> Creation d'un fils
Le pere itere une fois -> Creation d'un fils
Le premier fils continue son execution
Le second fils continue son execution
Le troisieme fils commence son execution
Le troisieme fils commence son execution
Le premier fils continue son execution
Le second fils continue son execution
Le troisieme fils continue son execution
Le quatrieme fils continue son execution

etc...

Chaque processeur a le droit a un certain quota de temps processeur, apres quoi il est retiré du processeur pour laisser la place a un autre. Donc chaque processus ne fait qu'une partie de son job avant qu'un autre processus fasse lui aussi une partie de son job...C'est cela que tu appelles la "parallelisation" : Des processus qui se partagent le CPU.

La veritable parallelisation concerne les systemes multi-coeurs et/ou multi-processeurs mais ca c'est un autre probleme
19/03/2007, 15h29
souviron34

Citation:

Envoyé par v4np13

Je peux difficilement faire une boucle car je veux que les processus fils s'exécutent en même temps. Pas de la programmation séquentielle.
....
Donc je recherche le parallélisme sans savoir combien de fichiers je vais devoir traiter à l'avance, d'où l'idée d'une fonction récursive.

C'est strictement identique..

Puisque tu fait une boucle de fork, tu lances (à la vitesse de la boucle, sans doute un peu plus rapide que une fonction récursive) des processus dfférents, qui chacun fera sa copie...

Voici un code qui peut faire ce que tu veux avec une boucle :

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
 
void copie(char *f)
{
    printf("Hello %s\n",f);
}
 
int lancement(char *file) 
{
    printf("Forked\n");
    pid_t p = fork();
 
    if(p == -1) {
        perror("Erreur de fork()");
        return -1;
    }
 
    if(p==0) { 
        /*Fils*/
        copie(file);
        /* Fils termine */
        exit(EXIT_SUCCESS);
    }
    return 1;
}
 
int traitement(int argc, char *argv[])
{
    int i;
    for(i=1;i<argc;i++) {
        int res = lancement(argv[i]);
 
        if(res == -1) {
            return -1;
        }
    }
    return 0;
}
 
int main(int argc, char * argv[])
{
    if (argc <= 2){
        perror("Entrez au moins un argument!");
    }
    else{
        if (traitement(argc,argv) == 0 ){
            int i;
            for(i=1;i<argc;i++) {
                wait(NULL);
            }
        }
        else{ 
            perror("Erreur de traitement");
            return -1;
        }
    }
    return 0;
}

Citation:

Envoyé par fearyourself

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main(int argc, char * argv[])
{
    if (argc <= 2){
        perror("Entrez au moins un argument!");
    }
    else{
        if (traitement(argc,argv) == 0 ){
            int i;
            for(i=1;i<argc;i++) {
                wait(NULL);
            }
        }
        else{ 
            perror("Erreur de traitement");
            return -1;
        }
    }
    return 0;
}

Tu pourrais m'expliquer la boucle de wait(NULL) ? Je pensais qu'un wait(0) suffisait.

Merci

19/03/2007, 15h59
fearyourself

Un appel à wait attend qu'un fils termine... Donc si tu lances N fils, il faut N wait...

Jc
19/03/2007, 16h27
v4np13

Je viens de faire des essais, la grosse différence avec ce que j'ai vu, c'est le exit(EXIT_SUCCESS);.

Nous ne l'avons pas encore vu au cours, je suppose que je ne dois pas l'utiliser pour faire l'exercice. En fonction de si je le mets ou pas, le fils s'exécute plusieurs fois.

Ca devrait être possible d'arriver au même résultat sans cette fameuse ligne? (le fonctionnement est fort similaire avec mon premier code, non?)
19/03/2007, 16h29
fearyourself

Citation:

Envoyé par v4np13

Je viens de faire des essais, la grosse différence avec ce que j'ai vu, c'est le exit(EXIT_SUCCESS);.

Nous ne l'avons pas encore vu au cours, je suppose que je ne dois pas l'utiliser pour faire l'exercice. En fonction de si je le mets ou pas, le fils s'exécute plusieurs fois.

Ca devrait être possible d'arriver au même résultat sans cette fameuse ligne? (le fonctionnement est fort similaire avec mon premier code, non?)

Oui mais je ne vois pas l'intérêt de le faire en récursivité...

Jc