Você está na página 1de 4

Clculo do valor Distribudo

Cristianne Rodrigues Santos Dutra1 Fernanda de Ftima Pereira2 PUC Minas So Gabriel Engenharia de Computao Sistemas Distribudos 1 {cristianne.dutra@yahoo.com.br} 2 {nanda.fatima@gmail.com}

1. Introduo
Um sistema distribudo um sistema que interliga vrios ns de processamento de maneira que um processo de grande consumo seja executado no n "mais disponvel" ou subdividido por vrios ns. Conseguindose, portanto, ganhos elevados, pois uma tarefa qualquer, se dividida em vrias subtarefas, pode ser realizada em paralelo.

time_fim = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0; onde: tv_sec retorna o tempo em segundos; tv_usec retorna o tempo em milissegundos.

2. Objetivo
O objetivo deste trabalho implementar a aproximao do clculo do pelo mtodo de Monte Carlo utilizando a linguagem C. Tambm ser realizada uma comparao e uma anlise crtica do tempo de execuo utilizando um algoritmo seqencial e um algoritmo distribudo.

O clculo do tempo de execuo obtido a partir da diferena entre time_fim e time_incio. A implementao do clculo do mostrada a seguir: for (i = 0; i < PontosTotal; i++) { x = (double)rand()/RAND_MAX; y = (double)rand()/RAND_MAX; double result = (x*x)+(y*y); if (result < 1) { PontosDentro++; } } double resultado = PontosDentro/PontosTotal; pi = resultado * 4.0;

3. Descrio da Implementao Sequencial


O algoritmo para o clculo do sequencial foi implementado sem grandes complicaes. Quando o programa executado, necessrio entrar com a quantidade de pontos que sero sorteados para o clculo do . O programa executa o algoritmo de Monte Carlo e logo aps exibe o valor aproximado do . Para o clculo do tempo de execuo, foi utilizado a biblioteca sys/time.h. A funo gettimeofday(&tv, &tz) recebe como parmetro a estrutura tv utilizada para armazenar o fuso horrio e a estrutura tz que armazena a hora atual, expressa em segundos e microssegundos, retornada pela funo. Para encontrar os horrios do incio e do trmino da execuo so realizados os clculos mostrados a seguir: time_inicio = (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;

(double)

A varivel PontosDentro guarda a quantidade de pontos dentro do crculo de raio unitrio. Os nmeros aleatrios entre 0 e 1 foram gerados a partir da funo rand(). O tipo escolhido para representar o nmero de pontos foi o long int. Segundo o padro ANSI C, esse tipo de dados possui 4 bytes de tamanho e seu limite mximo de valores 231 . Em nossa simulao foram utilizados valores em potncia de 10, assim conseguimos simular o calculo do com at 109 pontos, pois a partir desse no mais possvel representar a quantidade de pontos utilizando o tipo long int.

3.1 Manual de Utilizao

O programa foi implementado no sistema operacional Ubuntu verso 9.10. Para sua execuo necessrio seguir os passos abaixo: Para compilao do programa: gcc Pi_Sequencial.c -o Pi_Sequencial Para execuo do programa: ./Pi_Sequencial

Grfico 01 Algoritmo Sequencial, Tempo de Execuo x Quantidade de Pontos.

Analisando o grfico 01 podemos perceber que o tempo de execuo aumenta medida que a quantidade de pontos cresce. Esse resultado esperado, pois quanto maior a quantidade de pontos, mais valores aleatrios so gerados, mais clculos e mais comparaes so realizadas.

3.2 Anlise do Tempo de Execuo

4 Descrio da Implementao Distribuda


A execuo do programa para o clculo do tempo de execuo foi realizada nos laboratrio do Instituto de Informtica da PUC-Minas. Os computadores utilizados so computadores HP PRO 3000, com processador Core 2 Duo E7500 com freqncia de 2,9GHz, memria RAM DDR2 de 4Gb e HD de 320 Gb. O sistema operacional utilizado foi o Ubuntu verso 9.10, A quantidade de pontos selecionada para a execuo, bem como os tempos de execuo correspondentes so mostrados na tabela a seguir: Tabela 01: Quantidade de pontos e tempo de execuo do algoritmo seqencial. Tempo em segundos.
Pontos 10 100 1000 10000 100000 1000000 10000000 100000000 1000000000 Tempo 0,0000050 0,0000150 0,0001140 0,0011020 0,0095460 0,0727570 0,6266720 6,0155368 58,4617830

O algoritmo do clculo do distribudo foi implementado atravs de um processo servidor e processos clientes. Ao executar o programa necessrio informar para o processo servidor a quantidade de pontos que sero utilizados para o clculo do e a quantidade de processos clientes que iro efetuar o clculo. O processo servidor define a quantidade de pontos que cada processo cliente ir calcular de acordo com a quantidade de processos clientes selecionados. Para cada processo cliente, o processo servidor abre uma conexo. A conexo foi realizada de acordo com o algoritmo visto em sala de aula. A nica diferena foi a criao de um vetor de inteiros (new_socket[])para armzenar o retorno da funo accept, pois foi necessrio criar uma conexo para cada cliente, como pode ser visto abaixo. for (i=0; i< num_clientes; i++) { new_socket[i] = accept(create_socket, sockaddr*) & addrserver, &addrlen); if(new_socket[i] < 0) { printf("ERRO no accept... \n"); exit(0); } else { //Cria as threads PontosDentro_Cliente[i] = i; pthread_create(&p_threads[i], NULL, Conectar_Cliente, (void *) &PontosDentro_Cliente[i]); } } Aps a criao da conexo o processo servidor fica esperando que os clientes se conectem a ele. Para cada cliente conectado, o servidor cria uma thread.

(struct

Os resultados obtidos esto representados no grfico a seguir,

pthread_create(&p_threads[i], NULL, Conectar_Cliente, (void *) &PontosDentro_Cliente[i]); Cada thread criada vai executar Conectar_Cliente( ) mostrada a seguir: void *Conectar_Cliente (void *s) { idcliente = (int *) s; cliente = *idcliente; // Envia a mensagem (Numero de pontos) para o cliente send(new_socket[cliente], buffer_send, buffersize, 0); // Recebe a mensagem (Numero de pontos dentro) do cliente recv(new_socket[cliente], buffer_recv, buffersize, 0); // Imprime a mensagem que foi recebida pelo cliente printf("Mensagem recebida do cliente: %s\n", buffer_recv ); a funo

O clculo do tempo de execuo do programa idntico ao clculo do programa seqencial. Vale ressaltar que para no haver atrasos no clculo do tempo, cada cliente cria sua conexo (antes do servidor criar a conexo dele) e verifica se a conexo com o servidor possvel. Quando a conexo com o servidor estabelecida, o cliente recebe a quantidade de pontos, calcula os pontos que esto dentro do crculo unitrio e envia a resposta para o servidor.

4.1 Manual de Utilizao


Para a execuo do programa necessrio seguir os passos abaixo : Para compilao do processo cliente: gcc Pi_Cliente.c -o Pi_Cliente Para execuo dos programas clientes: ./Pi_Cliente Para compilao do programa servidor: gcc -pthread Pi_Servidor.c -o Pi_Servidor Para execuo do programa servidor: ./Pi_Servidor

sscanf(buffer_recv, "%d", &Resposta_Cliente[cliente]); // converte a string para inteiro // Soma a quantidade de pontos calculada PontosDentro +=Resposta_Cliente[cliente]; // Fecha o socket close(new_socket[cliente]); close(create_socket); pthread_exit(0); } Nesta funo, o servidor atravs do comando send envia para o cliente a quantidade de pontos que ele ir processar, armazenado na varivel buffer_send. Cada processo cliente ir calcular a quantidade de pontos dentro do crculo de raio unitrio e retornar o valor para o processo servidor. O servidor ir receber o resultado de cada cliente conectado (armazenado em buffer_recv do comando recv), e armazenar a soma do valor de cada cliente na varivel PontosDentro. Cada thread, que responsvel por uma conexo, fechar a conexo e ser destruda pelo servidor atravs do comando pthread_join(p_threads[i], NULL); e em seguida, o servidor realizar o clculo do exibindo a resposta.

4.2 Anlise do Tempo de Execuo


A execuo do programa na verso distribuda foi realizada em computadores com a mesma configurao do programa na verso seqencial. Foram necessrios quatro computadores para a execuo, um computador participou como o processo servidor e os outros trs como processos clientes. A quantidade de pontos para os testes, bem como os tempos de execuo do programa para um, dois e trs clientes conectados ao servidor mostrado a seguir: Tabela 02: Quantidade de pontos e tempo de execuo do algoritmo distribudo. Tempo em segundos.
Pontos 10 100 1000 10000 100000 1000000 10000000 100000000 1000000000 Tempo para 1 escravo Tempo para 2 escravos Tempo para 3 escravos 0,00450800 0,00462700 0,00455600 0,00571200 0,01574200 0,07478900 0,63714500 6,02746900 59,03087400 0,00441200 0,00449100 0,00452900 0,00519500 0,01132900 0,04488200 0,31981700 3,02890100 30,08432100 0,004231000 0,004164000 0,004271000 0,004547000 0,009677000 0,034616000 0,237111000 2,020040000 21,303324000

Grfico 02 Algoritmo Distribudo, Tempo de Execuo x Quantidade de Pontos.

Grfico 03 Algoritmo Sequencial versus Processo distribudo com apenas um processo cliente.

O Grfico 02 mostra que a quantidade de ns clientes concetados ao servidor altera o tempo de execuo do programa. Quanto maior a quantidade de processos clientes, menor o tempo para o clculo do valor do .

5. Dificuldades Encontradas
De maneira geral, a implementao do trabalho ocorreu de forma tranqila. A dificuldade encontrada foi na conexo com os trs clientes, pois a princpio no sabamos que era necessrio realizar trs accept, criando para isso um vetor que armazena o resultado dos trs accept. Nos testes, mantivemos a porta 7007, utilizada como exemplo em sala de aula, como padro para todas as conexes com os clientes. Outra dificuldade foi sincronizao do valor retornado por cada cliente com o clculo do finalizado pelo processo servidor, pois o servidor realizava o clculo antes que as threads retornassem o valor, assim o resultado ficava incorreto, pois ele era feito com a quantidade de pontos encontrados apenas por alguns dos clientes.

Logo, atravs dos experimentos conclumos que a abordagem distribuda uma ferramenta valiosa para aumentar o desempenho do tempo de execuo de programas.

7. Bibliografia
CRUZ, Adriano J. O; Tipos de Dados, Constantes e Variavis. Disponvel em: < http://equipe.nce.ufrj.br/adriano/c/apostila/tipos.htm> Acesso em 21 de set. 2011 C Plus Plus - Documentao C/C++. Disponvel em: < http://www.cplusplus.com/ > Acesso em 20 de set. 2011.

6. Anlise dos Resultados e Concluso


De acordo com os resultados obtidos nas fases anteriores, possvel observar que o tempo de execuo do clculo realizado atravs de um algoritmo seqencial maior que o realizado distribuidamente com mais de dois clientes. Notou-se tambm que a execuo com apenas um cliente mais lenta que o algoritmo seqencial, isto se deve ao tempo gasto para a criao, estabelecimento e fechamento da conexo (Grfico 03).

Você também pode gostar