Se connecter / S'enregistrer
Votre question

Gestion des pipes

Tags :
  • Programmation
Dernière réponse : dans Programmation
10 Mai 2010 15:05:51

Bonjour à tous

Voilà j'ai un projet en C qui a comme intitulés "gestion des pipes"
Mais je ne sais pas qu'est ce que je dois faire au juste.

Si quelques peux m'expliquer au moins le principe des pipes, quels sont les manipulations a faire.

Merci d'avance.

Autres pages sur : gestion pipes

10 Mai 2010 16:17:57

Le but d'un pipe est d'envoyer des informations d'un processus à l'autre.

Pour créer un pipe :

  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <sys/types.h>
  4.  
  5. main()
  6. {
  7. int fd[2];
  8.  
  9. pipe(fd);
  10.  
  11. }



Tu peux voir que c'est un tableau à 2 cases.
L'entrée se fait dans fd[1]
La sortie dans fd[0]

Tu peux envoyer des variables à travers ce tube pour faire communiquer 2 processus.

TU as aussi les tubes nommés. Les tubes nommés sont un fichier de type tube que tu créé sur le disque au travers duquel transite les informations. Je le trouve plus facile d'utilisation.

Ton projet doit dévelloper quel type de tube ?
m
0
l
10 Mai 2010 16:57:27

Bonjour,

Je ne souhaite ajouter qu'un petit exemple, apaachee t'as vraiment donné une excellente explication.

Soit le code suivant :
  1. #include <stdio.h>
  2. #include <unistd.h>
  3. #include <sys/types.h>
  4.  
  5. int main(void)
  6. {
  7. int fd[2], nbytes;
  8. pid_t childpid;
  9. char string[] = "Hello, world!\n";
  10. char readbuffer[80];
  11.  
  12. pipe(fd);
  13.  
  14. if((childpid = fork()) == -1)
  15. {
  16. perror("fork");
  17. exit(1);
  18. }
  19.  
  20. if(childpid == 0)
  21. {
  22. /* Child process closes up input side of pipe */
  23. close(fd[0]);
  24.  
  25. /* Send "string" through the output side of pipe */
  26. write(fd[1], string, (strlen(string)+1));
  27. exit(0);
  28. }
  29. else
  30. {
  31. /* Parent process closes up output side of pipe */
  32. close(fd[1]);
  33.  
  34. /* Read in a string from the pipe */
  35. nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
  36. printf("Received string: %s", readbuffer);
  37. }
  38.  
  39. return(0);
  40. }


Il s'agit d'une simple transmission d'un "Hello World" entre deux processus.

Allez, détaillons un peu le tout.
  1. int fd[2], nbytes;
  2. pid_t childpid;
  3. char string[] = "Hello, world!\n";
  4. char readbuffer[80];


Déclarations des variables comprenant donc:
  • le message à transmettre (string)
  • un buffer de lecture (readbuffer)
  • l'identifiant du processus fils (childpid)
  • un tableau d'entiers (fd) permettant de définir les descripteurs de fichiers utilisé par le "pipe"
  • un entier qui sera utile plus tard (nbytes).

    Jusque là, rien de spécial pour du développement en C...

    1. pipe(fd);


    Cette méthode système permet de créer 2 descripteurs de fichiers pour permettre la création d'un tuyau de communication entre 2 processus.

    SYSTEM CALL: pipe();

    PROTOTYPE: int pipe( int fd[2] );
    RETURNS: 0 on success
    -1 on error: errno = EMFILE (no free descriptors)
    EMFILE (system file table is full)
    EFAULT (fd array is not valid)

    NOTES: fd[0] is set up for reading, fd[1] is set up for writing


    Contrairement à ce qu'a dit apaachee,
  • La sortie (lecture) se fait dans fd[0]
  • L'entrée (écriture) se fait dans fd[1]

    Maintenant, la création d'un processus fils :
    1. if((childpid = fork()) == -1)
    2. {
    3. perror("fork");
    4. exit(1);
    5. }

    Ici, nous créons un "fork" du programme principal, la condition et le reste c'est juste pour un contrôle d'erreurs et éviter les mauvaises surprises.

    1. if(childpid == 0)
    2. {
    3. /* Child process closes up input side of pipe */
    4. close(fd[0]);
    5.  
    6. /* Send "string" through the output side of pipe */
    7. write(fd[1], string, (strlen(string)+1));
    8. exit(0);
    9. }


    Là nous traitons l'exécution du fils, dans cet exemple celui-ci ferme le descripteur de fichier fd[0] car il ne l'utilisera pas.
    Ensuite, il va écrire (write(...)) dans le descripteur de fichier fd[1] la chaine définie plus haut.

    1. else
    2. {
    3. /* Parent process closes up output side of pipe */
    4. close(fd[1]);
    5.  
    6. /* Read in a string from the pipe */
    7. nbytes = read(fd[0], readbuffer, sizeof(readbuffer));
    8. printf("Received string: %s", readbuffer);
    9. }


    Nous retournons à présent dans le programme principal (le papa) pour lire le message du fils, il commence donc par fermer le descripteur de fichier fd[1] car il ne l'utilisera pas.
    Ensuite, il va lire le message reçu dans le tuyau (read(...)) par l'intermédiaire du descripteur de fichier fd[0].
    La fonction "read" retourne le nombre d'octets lus, cela peut s'avérer plus qu'utilise dans certains cas.


    Voila, avec ça tu sais tout :o 
    m
    0
    l
    Contenus similaires
    10 Mai 2010 17:54:47

    Ah, je te remercie RedSux, je me suis permi d'éditer mon message en corrigeant mon erreur :) 

    Très beau tuto, j'aurais aimé le lire au tout début ^^
    m
    0
    l
    10 Mai 2010 18:01:22

    Je t'en pris, j'ai simplement pris un code (trouvé sur google) et expliqué les différentes parties.
    C'est pas grand chose.
    m
    0
    l
    13 Mai 2010 11:27:51

    Merci beaucoup les gars.

    Je crois que ces explications vont m'aider.

    Je une petit question appachee a parlé de tubes. Qu'est ce que c'est ?
    m
    0
    l
    13 Mai 2010 11:30:33

    Tube (francais) = Pipe (Anglais)

    ;) 
    m
    0
    l
    Tom's guide dans le monde
    • Allemagne
    • Italie
    • Irlande
    • Royaume Uni
    • Etats Unis
    Suivre Tom's Guide
    Inscrivez-vous à la Newsletter
    • ajouter à twitter
    • ajouter à facebook
    • ajouter un flux RSS