Pipes

Clase 32 de 37 • Curso de Introducción a C 2019

Andrés Felipe Aguirre Fajardo

student•

no se puede hace comunicación entre procesos con apuntadores?, ya que a pesar de que se hagan copias de las variables en el otro proceso si los apuntadores apuntan al mismo espacio de memoria, no se podría compartir información?

Mauro Chojrin

teacher•

En teoría se podría, pero depende del sistema operativo. Existen algunos S.O. que "muestran" a cada proceso un espacio de memoria independiente de los demás... en ese caso no será posible hacer lo que sugieres.

Diego Michael Zabala Montenegro

student•

Que buena pregunta crack

Sebastián Ariel Cóceres

student•

Las pipes son un canal de I/O artificial que utiliza un programa para pasar información a otros programas. Es un metodo de comunicación entre el proceso padre y el proceso hijo. Se trata de archivos virtuales en los que un proceso escribe y otro proceso puede leer. Si el proceso lector no encuentra nada en el la salida del pipe se bloquea hasta que algo aparezca. | | La funcion pipe(): |
Incluida en la libreria unistd.h
|
Para las pipes se debe definir un array de tipo entero de dos posiciones.[la posición «0» a modo de lectura y la posición «1» a modo de escritura]. | Las pipes «solo» tienen un sentido, si queremos hablar del padre al hijo, no podremos usar esa misma pipe para hablar del hijo al padre, para ello necesitamos crear otra pipe | Para crear la tubería se emplea la función pipe(), que abre dos descriptores de fichero y almacena su valor en los dos enteros que contiene el array de descriptores de fichero. El primer descriptor de fichero es abierto como O_RDONLY, es decir, sólo puede ser empleado para lecturas. El segundo se abre como O_WRONLY, limitando su uso a la escritura. De esta manera se asegura que el pipe sea de un solo sentido. |

Valentina Orejuela

student•

Gracias por este aporte.!!

Irving Juárez

student•

Me quedo un poco mas claro como funcionan los pipes y para que sirven

Federico Badiola

student•

Hola Mauro, Lo primero de todo, muy bien explicado. Me ha surgido alguna duda mientras veía los videos de pipes y de sockets y he vuelto hacia atrás para escribirlas y que me pueda dar su respuesta y opinión al respecto.

¿Por qué hacer un fork al proceso y no levantar threads? Si no tengo entendido mal, el coste de levantar un proceso es mayor que levantar un thread. A demás al tener memoria compartida la comunicación se puede hacer directamente a través de la memoria. Aunque también se podría hacer un mmap y que compartan memoria los dos procesos pero, IMHO creo que es menos llamativo, ¿qué opinas?
¿Los pipes sobre FS son ampliamente utilizados? ¿O soluciones como Signal o memoria compartida son más habituales en sistemas complejos o en producción? El contexto de mi pregunta es: la latencia de ir a disco o a red es muy superior a la memoria, se me hace extraño que en situaciones complejas se usen estos sistemas. Si bien es cierto que en sistemas con memorias muy limitadas y con capacidad de disco es buena manera para encolar mensajes arbitrariamente pesados.

Muchas gracias por la atención!!

Andres Condezo Monge

student•

Buenas preguntas....

Federico Moreno

student•

Si alguien utiliza Mac y Visual Studio Code y le salta error al compilar esta librería: #include <wait.h>, yo resolví ese error incluyéndola así: #include <sys/wait.h>. Espero que ayude.

marco antonio

student•

![](

noto que el resultado es un poco caótico y es muy posible que tu resultado sea diferente al mio o al del profe pero dejen que les explique por que pasa esto. La ejecución se hace de forma secuencial es decir que para ejecutar una función antes tienes que ejecutar main y si hay otra función adentro de esa función tiene que ejecutarse para poder terminar de ejecutar la función principal y volver a main. pero que pasa con las bifurcaciones como fork o pthread que la ejecución se hace de forma segmentada es decir hago un poco del padre y hago un poco del hijo y los pipes con sus punciones write y read permite hacer esperar a que un proceso no termine antes de que el otro lo haga. En conclusión cuando se trata de los hilos la ejecución se hace en saltos aquí dejo un pequeño diagrama para hacerlo mas gráfico, por cieto hice el ejercicio en pthread para windows por si quieren echarle un vistaso esta abajo de este comentario ![](

marco antonio

student•

estoy en windows asi que y lo hice con pthread mi problema surgio ya que con pthread no hay que hacer pipes lo cual esta ok pero eso significa que no hay una jeraquia asi que toca hacerlo con banderas de espera pero... eso solo esta en linux se llaman mutex entoces cree mis propias funciones de espera con whiles infinitos y punteros lo cual funciona pero es poco practico en fin el cogido funciona y cumple con el ejercicio de la clase ![](

intente hacer una recreación del texto que le salio al profe para que me salir casi lo mismo XD en fin si quieren saber mas de pthread les deseo suerte casi todo esta para linux y la mayoria en ingles aparentemente windows tiene el thread pero ni idea de como funciona les dejo mi código si quieren una explicación solo pídanla en los comentarios y responderé a menos que ya hayan pasado varios meses y ya no este por aquí XD

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define TERMINO 0
#define EN_ESPERA 1
#define SI 1
#define NO 0
#define MSGSIZE 16

typedef struct LLAVE_t Llave;

struct LLAVE_t{
    short Madre;
    short Hija;
    char Buffer[MSGSIZE];
    FILE *archivo;
    short RomperHilos;};

void *MadreLee(void * valor);
void *HijaBusca(void * valor);

Llave * IniciaLlave(const char *Ruta);
void LimpiaLlave(Llave *llave);

void Esperar(short *AquienEspero){
    while(*AquienEspero);}

int main(int argc, char **argv)
{
    if(argc < 2)return -1;

    Llave *Parametros;
    Parametros = IniciaLlave(argv[1]);

    pthread_t Madre;
    pthread_t Hija;

    if(pthread_create(&Madre,NULL,&MadreLee,Parametros))
       return -1;
    if(pthread_create(&Hija,NULL,&HijaBusca,Parametros))
       return -2;

    pthread_join(Madre,NULL);
    pthread_join(Hija,NULL);
    LimpiaLlave(Parametros);
    return 0;
}
Llave * IniciaLlave(const char *Ruta){
    FILE * archivo = fopen(Ruta,"r");
    if(archivo == NULL) return NULL;

    Llave *Maestra = (Llave*)malloc(sizeof(Llave));
    Maestra->Hija = TERMINO;
    Maestra->Madre = EN_ESPERA;
    Maestra->archivo = archivo;
    Maestra->RomperHilos = NO;
    return Maestra;}

void *MadreLee(void * valor){
    if(valor == NULL)return NULL;
    Llave *LLAVE = (Llave*)valor;
    short Ejecutar = 1;
    while (fgets(LLAVE->Buffer,MSGSIZE,LLAVE->archivo)){
        Esperar(&LLAVE->Hija);
        printf("MADRE : lei esto \"%s\"\n",LLAVE->Buffer);
        printf("Cual es la letra mas grande Hija\n\n");
        LLAVE->Madre = TERMINO;
        LLAVE->Hija = EN_ESPERA;
        }
    LLAVE->RomperHilos = SI;}

void *HijaBusca(void * valor){
    if(valor == NULL)return NULL;

    Llave *LLAVE = (Llave*)valor;
    while(1){
        Esperar(&LLAVE->Madre);
        int i;
        char Max = LLAVE->Buffer[0];
        for(i = 0; i < MSGSIZE;++i){
            if(LLAVE->Buffer[i] > Max)
                Max = LLAVE->Buffer[i];}
        printf("HIJA : la letra es : \"%c\" Mami\n\n",Max);
        LLAVE->Hija = TERMINO;
        LLAVE->Madre = EN_ESPERA;
        if(LLAVE->RomperHilos)
            break;}}

void LimpiaLlave(Llave * llave){
    if(llave == NULL) return;
    fclose(llave->archivo);
    free(llave);}

Jose Antonio Rojas Ollarves

student•

En pocas palabras los pipes son:

Son un intermediario de comunicacion entre padre y hijo, quiere decir que el padre puede escribir y el hijo puede leer o viceversa. Basicamente un pipe es un medio de comunicacion entre el hijo y el padre, lo que quiere decir que al ingresar un comando ya sea como hijo o padre tenga relacion con el hijo o el padre deacuerdo a su uso.

Sebastian Andree Lopera Quevedo

student•

¿como se cuando usar p[0] o p [1]? no lo entiendo.

Saúl Alejandro Tapia Loya

student•

Lo que entendí fue que p[1] lo usó para escritura y p[0] para lectura

Juan Eduardo Quintero Palacio

student•

Pipe 0 lee

Pipe 1 escribe

Guillermo Granado Garcia

student•

Al hacer el ejemplo el resultando en mi terminal no es el mismo que aparece en video. Primero muestra todos los pasos del padre y después todos los pasos del hijo. A qué se debe?

Además no me detecta la libreria wait.h. Pero diría que no me hace falta.

Estoy realizando los ejemplos con clang sobre MacOS

William Atef Tadrous

student•

me pasa igual

Sergio Brandon De Lucio Chavero

student•

#include<sys/wait.h

Rafael Arteaga

student•

estoy en el visual studio y cuando agrego la librería wait no me la reconoze porque? me dice que actualize el includepath como lo hago?

Juliana Gonzalez

student•

#include <sys/wait.h>

Yo tbm estoy usando VS code, puse asi como esta arriba y sin problema.

Sergio Brandon De Lucio Chavero

student•

utiliza #include<sys/wait.h>

Sebastian Andree Lopera Quevedo

student•

muchas clases entiendo el código pero no se como implementarlo por mi mismo hasta que busco en otras fuentes y me doy cuenta que esas clases no son necesarias porque lo entendi de otro lado. Mauro es muy buen profe pero quisiera que explique algo más lo que hace y porqué lo hace.

Joan Benavides Olivera

student•

Ejemple para pasar un mensaje desde el hijo (child) hasta el padre (parent). Me ha ayudado a entender mejor el ejercicio

//https://www.youtube.com/watch?v=Mqb2dVRe0uo&feature=youtu.be

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>

#define MSGLENTGH 99

int main(int argc, char * argv[])
{
  //this function requires an array of 2 integers. These integer are a filedescriptors which is a key to
  //read or write data in a file

  //array with 2 integers for the 2 keys
  int fd[2];
  //fd[0] - read
  //fd[1] - write

  //The fd opens when the pipe function runs. It is similar to fread and fwrite but it works with
  //multiple filedescriptors at the same time
  if (pipe(fd) == -1)
  {
    printf("Error. Pipe not opened");
    return -2;
  }

  //this process creates a parent process and a child process. The second one inheritates from the
  //first one and both have the 2 filedescriptors read (fd[0]) and write (fd[1]). In both processes
  //the 2 filedescriptors must be closed in order to finish each process
  int pid = fork();
  char message[MSGLENTGH];

  //father process (!= 0)
  if( pid )
  {
    //ends the write filedescriptor. Nothing to be write (send) from this process
    close(fd[1]);

    //starts the write filedescriptor. If fails return -3
    if(read(fd[0], &message, sizeof(char) * 99) == -1)
    {
      printf("Error. No read has been posible");
      return -3;
    }
    else
    {
      printf("PARENT. Message received from child process: '%s'\n", message);
    }

    //ends the read filedescriptor. No more data is read (received) from this process
    close(fd[0]);
  }

  //this error may appear when p.e. the user has any process with no permission
  else if( pid == -1)
  {
    printf("Error. No fork action");
    return -4;
  }

  //child process (== 0)
  else
  {
    //ends the read filedescriptor. No more data is read (received) from this process
    close(fd[0]);

    printf("CHILD. Enter a message (max. %d chars): ",MSGLENTGH);
    scanf("%[^\n]s", message);

    //starts the write filedescriptor. If fails return -4
    if(write(fd[1], &message, sizeof(char) * 99) == -1)
    {
      printf("Error. No write has been posible");
      return -5;
    }
    printf("CHILD. Message sent to parent process: '%s'\n", message);

    //ends the write filedescriptor. Nothing to be write (send) from this process
    close(fd[1]);
  }

  return 0;
}

Reinaldo Mendoza

student•

Toda la ayuda es bien recibida, este video fue el mas complejo de todo el curso hasta ahora

Juan Nuñez

student•

No entendí nada :(

Reinaldo Mendoza

student•

Y esta difícil, pero repítelo tanto como te sea necesario

Edinson Padrón

student•

Mi intento via un muy simple cat

/* Libraries ********************************************************/
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;string.h&gt;
#include &lt;unistd.h&gt;
#include &lt;wait.h&gt;
/********************************************************************/

/* Constants ********************************************************/
#define BUFFER_SIZE 100

#define NO_FILE_ERROR -1

#define FILE_OPEN_ERROR -2
/********************************************************************/

/* Types ************************************************************/
typedef int IN_OUT_PIPE_DESCRIPTOR[2];

typedef int PID;
/********************************************************************/

/* Functions ********************************************************/
int parent(IN_OUT_PIPE_DESCRIPTOR inOutPipe, char* filePath) {
  FILE* fp;

  if (!(fp = fopen(filePath, &quot;r&quot;))) {
    return FILE_OPEN_ERROR;
  }

  for(char buffer[BUFFER_SIZE]; !feof(fp); fgets(buffer, BUFFER_SIZE, fp)) {
    write(inOutPipe[1], buffer, BUFFER_SIZE);
  }

  close(inOutPipe[1]);

  wait(NULL);

  return 0;
}

int child(IN_OUT_PIPE_DESCRIPTOR inOutPipe) {
  close(inOutPipe[1]);

  char buffer[BUFFER_SIZE];

  while (read(inOutPipe[0], buffer, BUFFER_SIZE)) {
    fputs(&quot;&gt; &quot;, stdout);
    fputs(buffer, stdout);

    if (strchr(buffer, '\n') == NULL) {
      fputs(&quot;\n&quot;, stdout);
    }
  }

  return 0;
}
/********************************************************************/

/* Main *************************************************************/
int main(int argc, char* argv[]) {
  if (argc &lt; 2) {
    fputs(&quot;No file was supplied\n&quot;, stderr);

    return NO_FILE_ERROR;
  }

  IN_OUT_PIPE_DESCRIPTOR inOutPipe;

  pipe(inOutPipe);

  if (fork()) {
    return parent(inOutPipe, argv[1]);
  } else {
    return child(inOutPipe);
  }

  return 0;
}
/********************************************************************/

JOSE MANUEL PAREDES RAMIREZ

student•

Comunicación entre procesos: Para la comunicación entre procesos usamos pipes, se pueden comunicar procesos padre-hijo o que no tengan esa relación (La comunicación es bidireccional, es decir el padre lee y el hijo escribe o viceversa)

Allison Peña

student•

Esta clase me fue muy difícil de entender. siento que no se explico bien algunas funciones como fgets(), write() y read(). Pude entenderlo después de un tiempo. pero estuve re-viendo la clase muchas veces.

Alonso Felipe Jara Arias

student•

Estoy desde Windows y no puedo usar el fork, hay alguna función similar? y si lo hay como se podría implementar?

Carlos Lefin Henriquez

student•

Al parecer el codigo del profesor nunca funciono. Los printf no salieron como se supone que debiese salir. El profesor hace los codigos al momento, debiese de hacer pruebas y si es necesario grabar de nuevo, se graba. pero dejarnos confundido lo unico que resulta es hacernos pensar que el curso se hizo a la rapida y sin planificacion.

Filippo Cucina

student•

#include <sys/wait.h> en caso de que no les funcione #include <wait.h>

Andres Caro

student•

//ejemplo de pipes
//Agregamos librerias
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h> /*Agregamos libreria para usar for*/
#include <string.h>
#include <wait.h>

#define MSGSIZE 16 /*Definición de una macro para el tamaño del mensaje que estara leyendo el mensaje cada 16 caracteres*/

int main (int argc, const char argv[]){
    FILE * in; 
    int pid, p[2];
    /*la función pipe va devolver los numeros que identifique en el sistema operativo*/
    if (pipe(p) < 0){
        printf("No pude crear los pipes\n");
        return -2;
    }

    if (!(in= fopen(argv[1], "r"))){
        printf  ("No pude leer el archivo %s\n", argv[1]);
        return -1;
    }
/*si soy el proceso padre voy a crear un buffer del tamaño de la constante ya definida*/
    if (pid = fork()){
        char buffer[MSGSIZE];
        printf ("++ Soy el padre. Voy a leer desde %s\n", argv[1]);
        while (fgets(buffer, MSGSIZE, in)){
            printf("lei %s. Diem %d: Cual es el caracter mas grande?\n", buffer, pid);
            write (p[1],buffer, MSGSIZE);
        }
        close(P[1]); /*Cerramos el pipe para que no se pueda leer y escribir en el*/
        printf ("Esperando a mis hijos\n");
        wait(NULL);
        fclose(in);
    }else{ /*Ejecutamos los arreglos de nuestro hijo*/
        close(p[1]);/*Cierre de la escritura*/
        printf ("soy el hijo. Espero que aparezca algo en el pipe\n");
        char buffer [MSGSIZE], max;

        while (read(p[0], buffer, MSGSIZE)>0){
            printf("Lei '%s' desde el pipe\n", buffer);
            max =buffer[0];
            for (int i = 0; i< MSGSIZE; i++){
                if (buffer[i]>max){
                    max =buffer[i];
                }
                printf ("Max; '%c'\n", max);

            }

        }
   
    }
    return 0; 
    
}