IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Linux Discussion :

[Debutant] Tubes non nommés, fork et crible d'Ératosthène


Sujet :

Linux

  1. #1
    Membre régulier

    Profil pro
    Étudiant
    Inscrit en
    Mars 2013
    Messages
    118
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2013
    Messages : 118
    Points : 81
    Points
    81
    Par défaut [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...
    (j'ai mis que le principal, exit certains tests et messages d'erreurs correspondants)


    Code c : 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
    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 c : 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
    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 c : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  2. #2
    Responsable 2D/3D/Jeux


    Avatar de LittleWhite
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Mai 2008
    Messages
    26 826
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Mai 2008
    Messages : 26 826
    Points : 218 287
    Points
    218 287
    Billets dans le blog
    117
    Par défaut
    Bonjour,

    Citation Envoyé par Jéjé34 Voir le message
    Pourquoi ferme-on la sortie du tube quand on est dans le processus père?
    Car il n'a pas besoin d'écrire (mais la sortie n'est fermée que après écriture de la borne), c'est l'entrée qui est fermé au tout début (si j'ai bien suivi)
    Citation Envoyé par Jéjé34 Voir le message
    Pourquoi caste-on l'entier i en void*?
    Car la fonction write accepte uniquement des void*

    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
    Vous semblez avoir bien compris.

    Même questions que ci dessus? Pourquoi ces (void*) et ces closes?
    On ferme tout ce que l'on utilise pas (ou ce dont l'on a pas besoin, c'est mieux)

    Autre question: un tube fonctionne comme une file?
    Oui

    Elle "défile" le premier, et le tube conserve tous les autres nombres
    Oui

    Je vous conseille de rajouter des printf, pour comprendre comment fonctionne le programme. Je vous conseille de lire les manpages et dernier conseil, lorsque vous êtes incertain, de faire des tests dans des petits programmes.
    Vous souhaitez participer à la rubrique 2D/3D/Jeux ? Contactez-moi

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Membre régulier

    Profil pro
    Étudiant
    Inscrit en
    Mars 2013
    Messages
    118
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2013
    Messages : 118
    Points : 81
    Points
    81
    Par défaut
    Avec un peu de retard: merci LittleWhite.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Debutant] Exceptions non traitées
    Par L. Sierra dans le forum Langage
    Réponses: 4
    Dernier message: 24/09/2006, 20h16
  2. [Debutant] Enregistrement non trier
    Par Natsboss dans le forum Access
    Réponses: 4
    Dernier message: 21/08/2006, 00h48
  3. Utilisation de tubes dans des fork
    Par je®ome dans le forum Linux
    Réponses: 4
    Dernier message: 31/05/2006, 22h50
  4. [Debutant] Lecture non destructrice !
    Par Treuze dans le forum C
    Réponses: 5
    Dernier message: 18/05/2006, 19h22
  5. [debutant] JDialog non modal
    Par andresan dans le forum Agents de placement/Fenêtres
    Réponses: 10
    Dernier message: 12/05/2004, 14h40

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo