Lancement de plusieurs processus

**Premium** · 28/05/2006, 07h45

Bonjour,

je suis débutant en programmation systeme, je sollicite votre aide pour m'aider à écrire le main de mon programme.
Pour l'écriture du programme, il faut uniquement que j'utilise des fork, pipe... car je n'ai pas vu les threads...

J'explique ce qu'il faut faire :

-avoir plusieurs traceroute s'effectuant simultanément, afin de rassembler des informations le plus vite possible
-pouvoir choisir à la volée combien de traceroute on souhaite exécuter en parallèle)
-ajouter de nouvelles « cibles » pour traceroute pendant que l'ensemble fonctionne.

Les résultats des traceroute (avec l'option -n) lancés doivent être écrits dans un fichier pour pouvoir analyser les lignes et ainsi créer un graphe.

Le parsing et la création du graphe ont été faits, c'est le lancement des traceroutes et l'écriture dans le fichier qui pose problème.

Voici ce que j'ai écrit. Il n'est pas complet et aimerait que vous m'aidez pour faire en sorte qu'il le soit.

Merci par avance

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
// structure pour gérer une info fils => père
typedef struct {
  info1;
  info2;
  info3;
  info4;
  //...les infos qu'il faut
} t_info;
 
// structure pour gérer un fils et son pipe
typedef struct {
  int cote[2];               // Cotés du pipe
  int pid;                  // PID du fils
} t_fils;
 
int main(void)
{
  t_fils tabFils[n];           // Tableau des fils
  int i;                           // Boucle
  int nbFils;                   // Nb fils vivants
  t_info info;                  // Info transmise
 
  // Création des processus
  for (i=0; i < n; i++)
    {
      // Ouverture du pipe pour le fils vers son père
      pipe(tabFils[i].cote);
 
      // Création du processus fils
      if ((tabFils[i].pid=fork()) == 0)
    {
      // Ici on est dans le fils "i"
 
      // On commence par fermer le coté de lecture inutile
      close(tabFils[i].cote[0]);
 
      // Traceroute vers ip X
      //...
 
      // Récupération de toutes les IP situées entre moi et "x" => tableau d'IP
      //..
 
      //  Transmission de ce tableau vers le père par le pipe
      for (//...)
      {
        // Remplissage infos (une des info pourrait être le n° du fils)
        info.info1=i;
        info.info2=//...
          //... (on remplit toutes les infos)
 
          // On envoie l'info au père
          write(tabFils[i].cote[1], &info, sizeof(info);
 
         // on envoie une info particulière signifiant "fini"
         write(tabFils[i].cote[1], "EOT", 4);
 
        // Toutes les Ip sont transmises - Fin du fils (mais fermeture pipe avant)
        close(tabFils[i].cote[1]);
        exit(0);
      }
 
      // Ici on est dans le père - On n'a rien à faire sauf à fermer le coté d'écriture inutile
    close(tabFils[i].cote[1]);
    }
 
        // Ici, tous les fils sont lancés - On scrute maintenant les pipes tant qu'il y a des fils
        nbFils=n;
      while (nbFils > 0)
      {
        // On lit tous les pipes des fils
        for (i=0; i < n; i++)
          {
        // Si le fils "i" n'existe plus on le saute
        if (tabFils[i].pid == 0)
          continue;
 
        // Lecture du pipe venant du fils "i"
        if (read(tabFils[i].cote[0], &info,  sizeof(info)) > 0)
          {
            // Si on a reçu l'info particulière "EOT"
            if (//... == "EOT")
            {
              // On ferme le pipe de ce fils
              close(tabFils[i].cote[0]);
 
              // Le fils a terminé => pid mis à 0 (permettra de ne plus le traiter)
              tabFils[i].pid=0;
 
              // Un fils en moins
              nbFils--;
 
              // Inutile d'en faire plus pour ce crevard
              continue;
            }
 
            // Ici, on a reçu les infos sur les IP pour le fils "i"
            //... => on les analyse et on construit le graphe
         }
 
        // ici, soit on n'a rien reçu, soit on a fini de traiter les infos => on reboucle sur le fils suivant
            sleep(1);
   }
}
// Ici, il n'y a plus de fils
 
}

**gorgonite** · 28/05/2006, 19h52

perso, je séparerais la création des processus / assignement des sens dans les tuyaux, etc. du reste des opérations...

lis ce cours http://www.ensta.fr/~gueydan/Poly/Html/ et surtout les exemples

**Premium** · 29/05/2006, 13h23

Salut,

sur le code que j'ai commencé à écrire, est-ce que tu pourrais m'aider à le compléter?

Merci

**gorgonite** · 29/05/2006, 20h08

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
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
void traite_fils(t_info* info, t_fils* tuyau) {
    for (i=0; i < n; i++) {
         // Traceroute vers ip X
      //...
 
      // Récupération de toutes les IP situées entre moi et "x" => tableau d'IP
      //..
 
      //  Transmission de ce tableau vers le père par le pipe
      for (//...)
      {
        // Remplissage infos (une des info pourrait être le n° du fils)
        info->info1=i;
        info->info2=//...
          //... (on remplit toutes les infos)
 
          // On envoie l'info au père
          write(tuyau->cote[1], info, sizeof(*info);
 
         // on envoie une info particulière signifiant "fini"
         write(tuyau->cote[1], "EOT", 4);
 
        // Toutes les Ip sont transmises - Fin du fils (mais fermeture pipe avant)
        close(tuyau->cote[1]);
        exit(EXIT_SUCCESS);
    }
} 
 
int main(int argc, char** argv)
{
  t_fils tabFils[n];           // Tableau des fils
  int i;                           // Boucle
  int nbFils;                   // Nb fils vivants
  t_info info;                  // Info transmise
 
  // Création des processus
  for (i=0; i < n; i++)
    {
      // Ouverture du pipe pour le fils vers son père
      if (pipe(tabFils[i].cote) == -1) {
        perror("pipe");
        exit(EXIT_FAILURE);
      }
 
      // Création du processus fils
      tabFils[i].pid = fork();
      switch (tabFils[i].pid)
    {
        case -1:
            perror("fork");
            exit(EXIT_FAILURE);
        case 0:  // Ici on est dans le fils "i"  
            // On commence par fermer le coté de lecture inutile
            close(tabFils[i].cote[0]);
            traite_fils(&info,&tabFils[i]);
            break;
        default:
            // Ici on est dans le père - On n'a rien à faire sauf à fermer le coté d'écriture inutile    
            close(tabFils[i].cote[1]);
            break;
    }
 
 
  // on est sur d'etre dans le pere...
 
 
        // Ici, tous les fils sont lancés - On scrute maintenant les pipes tant qu'il y a des fils
        nbFils=n;
      while (nbFils > 0)
      {
        // On lit tous les pipes des fils
        for (i=0; i < n; i++)
          {
        // Si le fils "i" n'existe plus on le saute
        if (tabFils[i].pid == 0)
          continue;
 
        // Lecture du pipe venant du fils "i"
        if (read(tabFils[i].cote[0], &info,  sizeof(info)) > 0)
          {
            // Si on a reçu l'info particulière "EOT"
            if (//... == "EOT")
            {
              // On ferme le pipe de ce fils
              close(tabFils[i].cote[0]);
 
              // Le fils a terminé => pid mis à 0 (permettra de ne plus le traiter)
              tabFils[i].pid=0;
 
              // Un fils en moins
              nbFils--;
 
              // Inutile d'en faire plus pour ce crevard
              continue;
            }
 
            // Ici, on a reçu les infos sur les IP pour le fils "i"
            //... => on les analyse et on construit le graphe
         }
 
        // ici, soit on n'a rien reçu, soit on a fini de traiter les infos => on reboucle sur le fils suivant
            sleep(1);
   }
}
// Ici, il n'y a plus de fils
 
exit(EXIT_SUCCESS);
}

ps:
- je n'ai pas vérifié... mais c'est l'idée
- penses à faire une indentation correcte

**Premium** · 30/05/2006, 09h05

Salut,

est-ce que quelqu'un pourrait m'indiquer à quel momment dans le code lancé les traceroute ainsi que le fait de mettre le résultat dans un fichier car je doit le parser pour créer le graphe.

la fonction de parsing à ce prototype char **Parsing(FILE *fichier) et la création du graphe CreerGraphe(char **tab)

Merci

**gorgonite** · 30/05/2006, 12h11

tu mets dans un fichier texte avant de fermer le père... car il aura tout reçu.
après tout dépend du format, et de ce que tu souhaites.

par exemple, tu peux stocker dans un tableau de liste, et tout bien réécrire avec le numéro de fils, etc

le traceroute doit être lancé dans le traite_fils...

Lancement de plusieurs processus

Administration système

Discussions similaires

Partager

Partager