BCC - Projeto de Sistemas Distribuídos

Exemplos

Construções OpenMP

laco_paralelo_v0.c:
- Compilar com gcc -Wall -Wextra laco_paralelo_v0.c -o v0. Isso deve gerar um programa que não executa mais de uma thread.
- Compilar com gcc -Wall -Wextra -fopenmp laco_paralelo_v0.c -o v0. Isso deve gerar um programa que executa várias threads.
- Remover o #pragma omp parallel ... e compilar com gcc -Wall -Wextra -fopenmp laco_paralelo_v0.c -o v0. Isso deve gerar um programa que não executa mais de uma thread.
Compilar o laco_paralelo_v1.c com gcc -Wall -Wextra -fopenmp laco_paralelo_v1.c -o v1.
- Veja como as iterações do for são repetidas: cada thread executa todas as iterações em ordem!
- Remova o comentário da linha 10 (habilite o #pragma omp parallel), recompile e veja como as iterações do for agora são distribuídas entre as threads e não possuem mais ordem!
- Teste com mais ou menos threads (4, 8, 16, 32, 64) para entender como a distribuição de carga é feita. Use a variável de ambiente export OMP_NUM_THREADS=8. Você também pode fazer #pragma omp ... num_threads(8). Nesse último caso, lembre que você precisa recompilar o código!
Compile e teste o pi_v0.c. Esse é o código do cálculo do Pi usando a aproximação por integral, versão sem paralelização.
Compile e teste a v1 paralelizada em pi_v1.c.
- Meça o tempo com time ./v1 para 1, 2, 4, 8 threads. Altere a quantidade de threads no início do arquivo, em NUM_THREADS. Note que o desempenho não escala com o aumento de threads, por conta do falso compartilhamento.
Compile e teste a v2 paralelizada em pi_v2.c.
- Meça o tempo com time ./v2 para 1, 2, 4, 8 threads. Veja que agora o padding resolve o desempenho.
Compile e teste a v3 paralelizada em pi_v3.c. Essa versão usa a variável sum local para não gerar falso compartilhamento. Essa versão também usa a construção para regiões críticas para alterar a variável compartilhada pi.
Compile e teste a v4 paralelizada em pi_v4.c. Essa versão usa a diretiva #pragma omp for. Note que agora o controle do laço e a divisão de carga é feita automaticamente pelo OpenMP: não precisamos mais fazer os cálculos de início e fim para cada thread.
Compilar o laco_paralelo_v2.c com gcc -Wall -Wextra -fopenmp laco_paralelo_v2.c -o v2.
- Repita várias vezes a execução, com diferentes quantidades de threads.
Compilar o soma.c com gcc -Wall -Wextra -fopenmp soma.c -o soma. Adicione um printf dentro do for para mostrar qual thread está executando cada iteração. Depois, teste as variantes de distribuição de carga com schedule.
Compile e teste a v5 paralelizada em pi_v5.c. Essa versão combina parallel for e simplifica bastante parte do trabalho que já fizemos. Veja que voltamos a usar o vetor sum[], com uma posição para cada thread guardar a sua soma parcial.
Compilar o media.c com gcc -Wall -Wextra -fopenmp media.c -o media. Esse código calcula a média dos itens de um vetor usando redução.
Compile e teste a v6 paralelizada em pi_v6.c. Essa versão usa reduções para simplificar o código.
Perceba como o código abaixo tem uma dependência entre iterações do laço na variável j. Note que é possível resolver essa dependência desdobrando o cálculo, como feito na linha comentada.
```
int i, j, A[MAX];
j = 5;
for (i = 0; i < MAX; ++i) {
	j += 2;
	// DEPENDÊNCIA ENTRE ITERAÇÕES!
	// int j = 5 + 2 * (i+1);
	A[i] = big(j);
}
```