Paralelo.docx

UNIRV - UNIVERSIDADE DE RIO VERDE FACULDADE DE ENGENHARIA DE SOFTWARE

COMPARAÇÃO PRÁTICA ENTE PROCESSAMENTO PARALELO E PROCESSAMENTO LINEAR COM PADRÃO OPENMP

ALUNO: FERNANDO HENRIQUE DA SILVA PROFESSOR: SANDO SILVA MOREIRA

RIO VERDE - GO 2014

INTRODUÇÃO Este trabalho visa relatar a comparação no apecto prático entre um script utilizando técnicas de Processamento Paralelo e Processamento Linear utilizando o padrão OpenMP em sistema SMP (Symetric Multiprocessor System) . A máquina utilizada tem a seguinte configuração de processamento:

O SCRIPT O script em C compilado diretamente pelo Terminal Shell do sistema operacional Ubuntu (pois possui o pacote de métodos e classes OpenMP nativos) executa a função simples de uma estrutura de looping “for” que irá somar valores: for ( i = 0 ; i <= limite; i++ ) { soma = soma + } O objetivo do código será acumular a somatória dos números reais inteiros entre 0 e 1.000.000. Utilizando métodos de somatória de tempo para do pacote OpenMP (omp.h) tanto para o teste linear quanto para o paralelo para aferir o desempenho. Temos o seguinte script para nossa aplicação linear:

#include #include <stdio.h> #include <stdlib.h> int main() { int i; int max=1000000; double soma=0; double end=0, start=0, tempo=0; for(i=0; i<=max; i++){ soma=soma+i; } end = omp_get_wtime(); tempo=end-start; printf("Soma: %.0f \n", soma); if(tempo>=1) printf("Tempo: %.5f segundos \n", tempo); else printf("Tempo: %.5f milisegundos \n", tempo*1000); } Quando executamos o código temos os seguintes resultados:

Figura 1 – Execução do script Paralelo

Percebemos que o valor da somatória está condizente com o real 500.000.500.000 e que o tempo de execução este entre 8,02151 e 13,14910 milissegundos. Esta oscilação se dá porque o sistema está processando outras informações além do nosso script.

DIRETIVAS OPENMP UTILIZADAS As diretivas do OpenMP são baseadas na diretiva #pragma definida no padrão da linguagem C/C++. Os compiladores que suportam OpenMP em C/C++ possuem uma opção de linha de comando que ativa e permite a interpretação das diretivas do OpenMP. FORMATO DAS DIRETIVAS O formato padrão de uma diretiva OpenMP é mostrado a seguir: #pragma omp nome_da_diretiva [cláusula,...] novalinha Diretiva para o “for” Paralelo: #pragma omp parallel for for(i=0; i<=max; i++){ soma=soma+i; } Neste trecho a linha “#pragma omp parallel for” permite que cada processo matemático seja executado pela thred que está disponível. Porém acarreta o erro ao resultado final pelo fato de deixar que uma thred execute o cálculo simultaneamente a outra desencadeando uma falha de gravação dos dados.

Figura 2 – 1ª Execução do código Paralelo

Na Figura 1 Podemos observar o resultado da execução do código paralelo sem qualquer proteção contra o compartilhamento de uma variável para soma por todas as Threds ativas do sistema. Na linha onde se lê soma percebe-se que os valores não condizem com o esperado e a cada execução eles mudam pelo erro de gravação.

REDUCTION A cláusula reduction gera cópias da lista de variáveis definidas para cada thread e após o processamento reduz o resultado conforme a operação definida na cláusula. reduction (operador: lista de variáveis)

Colocando em nosso script paralelo: #pragma omp parallel for reduction(+:soma)

Com as diretivas OpenMP totalmente incluídas no script: #include #include <stdio.h> #include <stdlib.h> int main() { int i; int max=1000000; double soma=0; double end=0, start=0, tempo=0; start = omp_get_wtime(); omp_set_num_threads(4); #pragma omp parallel for reduction(+:soma) for(i=0; i<=max; i++){ soma=soma+i; } end = omp_get_wtime(); tempo=end-start; printf("Soma: %.0f \n", soma); if(tempo>=1) printf("Tempo: %.5f segundos \n", tempo); else printf("Tempo: %.5f milisegundos \n", tempo*1000); }

Executando o código:

Figura 3 - Execução do script final Paralelo

Observamos que o resultado foi um mais satisfatório ficando com o tempo de processamento entre 3,96904 e 6,98969 milissegundos contra 8,02151 e 13,14910 milissegundos. Conclusão Comparando as médias entre os resultados: Script Linear Script Paralelo Ganho de tempo

10,5853305 milissegundos 5,479365 milissegundos 48,24%

Em processamentos de grande porte o ganho de tempo de processamento que resultaram nossos testes são ainda mais drásticos sendo a utilização do padrão de Processamento Paralelo extremamente satisfatório. OBSERVAÇÕES O script paralelo que definiu o resultado final foi executado setando-se 4 treads mas ao deixa a escolhe livre não houve mudança considerável de tempo de execução. O sistema seta automaticamente a utilização de apenas 2 Threds. Ao forçar a utilização de uma grande quantidade a mais de threds o processamento do script fica mais lento. Problema ilustrado nas imagens abaixo:

Figura 4 – Setando 300 threads teoricamente gerenciadas pelo sistema

Figura 5 – Executando script e obtendo o maior tempo de execução