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 <omp.h>
#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 <omp.h>
#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 10,5853305 milissegundos
Script Paralelo 5,479365 milissegundos
Ganho de tempo 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