ECATI - Escola de Comunicao, Artes e Tecnologias da Informao ULHT Universidade Lusfona de Humanidades e Tecnologias Licenciatura em Engenharia Informtica / Informtica

a de Gesto (1.o Ciclo) Unidade Curricular: Sistemas Operativos Componente Prtica (2011/2012)

Trabalho N 4 - Comunicao Entre Processos

1. Introduo A comunicao entre processos ( IPC - Inter Process Communication) permite que dois processos possam trocar informao entre si. Existem vrias formas de IPC. Os PIPEs , disponveis em inmeros Sistemas Operativos, so uma das mais fceis de utilizar, permitindo criar canais monodireccionais (half-duplex) entre dois processos. Por outro lado, a gesto da interactividade com o utilizador, em simultneo com outras tarefas de I/O, obriga a utilizar vrios fluxos de execuo numa aplicao. Essa gesto hoje em dia maioritariamente realizada com base no conceito de thread (ou actividade). Com este trabalho pretende-se que os alunos aprendam a utilizar diferentes fluxos de execuo para gerir mltiplos canais de entrada e sada de dados num processo.

2.

Trabalho a realizar 2.1 Usando a chamada de sistema pipe(2), crie um programa que: a) use a chamada fork() para criar um filho, b) o processo pai deve comunicar atravs do pipe com o filho, enviando-lhe todos os dados que l do standard input (at obter um EOF) c) O filho cria um ficheiro (nome irrelevante) onde escreve os dados recebidos. d) Modifique o programa para que o filho comunique com o pai, usando tambm um pipe. Para criar um pipe, invocar o comando pipe. Fornecer um array de inteiros de tamanho 2. A chamada para o descritor de ficheiro de leitura encontra-se na posio 0 e o descritor de ficheiro de escrita na posio 1. Utilize a seguinte estrutura do programa (criar_pipe.c):
/* criar_pipe.c */ /* O seguinte exemplo cria um processo filho e comunica via pipes */

Sistemas Operativos

1 /4

2011/2012

#include #include #include #include

<sys/types.h> <unistd.h> <stdio.h> <stdlib.h>

/* l caracteres do pipe. */ void ler_do_pipe(int file) { // l do standard input (at obter um EOF) //.... } /* Escreve texto para o pipe. */ void escrever_para_pipe(int file) { FILE *stream; stream = fdopen (file, "w"); fprintf (stream, "Hello, World!\n"); fclose (stream); } { int main (void) pid_t pid; int fd[2]; /* Criar o pipe. */ if (pipe(fd)) { fprintf (stderr, "Pipe falhou.\n"); return EXIT_FAILURE; } /* Criar o processo filho. */ pid = fork (); if (pid == (pid_t) 0) { /* Este e o processo filho. */ // terminar primeiro o descritor de ficheiro de escrita. // ler do pipe return EXIT_SUCCESS; } else if (pid < (pid_t) 0) { /* O fork falhou. */ fprintf (stderr, "Fork falhou.\n"); return EXIT_FAILURE; } else { /* Este o processo pai. */ // terminar primeiro o descritor de ficheiro de leitura. // escrever para o pipe return EXIT_SUCCESS; }

2.2 FIFO (acrnimo para First In, First Out) um pipe que tem um nome no sistema de ficheiros. Atravs do terminal linux um pipe criado explicitamente utilizando-se os
Sistemas Operativos 2 /4 2011/2012

comandos mknod ou mkfifo. Dois processos podem utilizar este pipe atravs do seu nome. Por exemplo, pode-se criar um FIFO com o nome fifo1 e escrever para ele:
$> mkfifo fifo1 $> cat > fifo1

Independentemente, num processo separado, ler o contedo do FIFO, executando o comando:

$> cat < fifo1

2.3 De modo programtico utilizada a funo mkfifo. O primeiro argumento o caminho no qual deseja criar o FIFO, o segundo parmetro especifica permisso do proprietrio do FIFO. Veja-se o seguinte exemplo (criar_fifo.c) para criar um FIFO com o nome fifo2 :
/* criar_fifo.c */ /* O seguinte exemplo cria um novo FIFO */ #include <sys/types.h> #include <sys/stat.h> #include <stdio.h> void main() { char *mypath = "fifo2"; if (mkfifo(mypath, 0666) != 0) printf("erro ao criar FIFO %s\n",mypath); else printf("FIFO %s criado com succeso!\n",mypath); return EXIT_SUCCESS; }

Crie o fifo2 utilizando o cdigo de exemplo:

$> gcc -o criar_fifo criar_fifo.c $> ./criar_fifo $> FIFO fifo2 criado com succeso!

Teste o fifo2 atravs do terminal linux, escrevendo para ele:

$> cat > fifo2

Independentemente, num processo separado, ler o contedo do fifo2, executando o comando:

$> cat < fifo2

2.4 Crie um programa que utiliza a biblioteca pthread e que cria 5 threads. Cada thread imprime uma mensagem "Hello World!", e depois termina. Utiliza a seguinte estrutura do programa (criar_threads.c):
Sistemas Operativos 3 /4 2011/2012

/* criar_threads.c */ /* O seguinte exemplo implementa threads */ #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NUM_THREADS 1 void *PrintHello(void *threadid) { long tid; tid = (long)threadid; printf("Hello World! sou eu, a thread #%ld!\n", tid); pthread_exit(NULL); } int main (int argc, char *argv[]) { pthread_t threads[NUM_THREADS]; int rc; long t; //ciclo de execuo de threads //.. /* ultima coisa que o main() deve fazer */ //terminar threads; //.. return EXIT_SUCCESS;

a) Compile-o e execute (dever usar a biblioteca pthread no momento da linkagem)..

$> gcc -o criar_threads criar_threads.c -lpthread $> ./criar_threads main: criar a thread 0 main: criar a thread 1 Hello World! sou eu, a thread #0! main: criar a thread 2 Hello World! sou eu, a thread #1! main: criar a thread 3 main: criar a thread 4 Hello World! sou eu, a thread #2! Hello World! sou eu, a thread #3! Hello World! sou eu, a thread #4!

b) Explique o seu funcionamento.

Sistemas Operativos

4 /4

2011/2012