O documento apresenta um mini-curso sobre programação paralela utilizando OpenMP. Ele introduz os palestrantes e seus backgrounds, objetivos do curso, e um roteiro que inclui a evolução dos microprocessadores, programação paralela, OpenMP e desafios futuros.

1. Mini Curso: Programação Paralela
utilizando OpenMP
Arthur F. Lorenzon
Antonio Carlos S. B. F.
Henrique O. Gressler
Márcia C. Cera

2. 2
Quem somos...
● Arthur Francisco Lorenzon:
● Bacharel em CC pela UNIPAMPA
● Aluno do PPGC/UFRGS
● Integrante do Laboratório de Sistemas Embarcados – UFRGS
● Henrique de Oliveira Gressler
● Márcia Cristina Cera
● Antonio Carlos S. B. Filho

3. 3
Quem somos...
● Arthur Francisco Lorenzon
● Henrique de Oliveira Gressler:
● Bacharel em Ciência da Computação pela UNIPAMPA
● Márcia Cristina Cera
● Antonio Carlos S. B. Filho

4. 4
Quem somos...
● Arthur Francisco Lorenzon
● Henrique de Oliveira Gressler
● Márcia Cristina Cera:
● Doutorado em Computação pela UFRGS
● Professora Adjunta da UNIPAMPA
● Pesquisadora da área de PPD
● Antonio Carlos S. B. Filho

5. 5
Quem somos...
● Arthur Francisco Lorenzon
● Henrique de Oliveira Gressler
● Márcia Cristina Cera
● Antonio Carlos S. B. Filho:
● Pós-Doutorado em Computação – UFRGS
● Professor Adjunto da UFRGS
● Bolsista de Produtividade em Pesquisa do CNPq – Nível 2

6. 6
Experiência dos Palestrantes...
● Diversas aplicações paralelizadas utilizando OpenMP
● Diversos trabalhos publicados utilizando OpenMP
● Participação em eventos/grupos de pesquisa:
● Maratona de Programação Paralela – Petrópolis/RJ 2012
● Grupo de Estudos para Maratonas de Prog. Paralela – GEMPP
● Trabalho de Conclusão de Curso

7. 7
Objetivos deste Mini-Curso
● Programação Paralela
● Técnicas de Programação Paralela com OpenMP
● Teoria
● Prática
● Desafios Futuros para a área de PPD

8. 8
Roteiro
● Evolução dos Microprocessadores
● Cenário Atual
● Programar Paralelo, Porque? Onde? Como?
● OpenMP:
● Noções Básicas
● Paralelismo de Laços
● Paralelismo de Seções
● Diretivas de Sincronização
● Desafios Futuros

9. 9
Evolução dos Microprocessadores

10. 10
Evolução dos Microprocessadores
Sobreposição na execução
de etapas da instrução
IF ID EX ME WB
IF ID EX ME WB
IF ID EX ME WB

11. 11
Evolução dos Microprocessadores
Múltiplas Unidades Funcionais
Hardware: Superscalar
Software: VLIW

12. 12
Evolução dos Microprocessadores
Melhora do desempenho utilizando
técnicas de computação paralela!

13. 13
Evolução dos Microprocessadores
Preocupação com
gerenciamento de energia!!!

14. 14
Evolução dos Microprocessadores
Paralelismo no Nível de Thread
Aumento da Performance

15. 15
Arquiteturas Multi-Core
● De forma simplificada um processador multi-core é colocar dois
ou mais processadores num mesmo processador/chip.
● Trabalho de processsamento ficará dividido entre os cores.
CPU 0 CPU 1

16. 16
Arquiteturas Multi-Core
● De forma simplificada um processador multi-core é colocar dois
ou mais processadores num mesmo processador/chip.
● Trabalho de processsamento ficará dividido entre os cores.
CPU 0 CPU 1

17. 17
Arquiteturas Multi-Core
● De forma simplificada um processador multi-core é colocar dois
ou mais processadores num mesmo processador/chip.
● Trabalho de processsamento ficará dividido entre os cores.
CPU 0 CPU 1

18. 18
Programação Paralela
“Programação Paralela é a capacidade de dividirmos
uma carga de trabalho entre vários processadores
dinamicamente e de forma eficiente!”

19. 19
O que paralelizar?
● Previsão do tempo e do clima
● Cálculos matemáticos
● Processamento de imagens
● Simuladores
● Componentes de Jogos*

20. 20
Porque Paralelizar?
● Processamento simultâneo de diversas tarefas
● Melhorar aproveitamento do hardware – ciclos ociosos
● Aumentar o desempenho da CPU
● Aplicações mais rápidas e eficientes – Redução do tempo de
computação

21. 21
Cenário Atual
Arquiteturas Multicore
Ferramentas
Motivos
Aplicações
Prós Contra

22. 22
Cenário Atual
Arquiteturas Multicore
Ferramentas
Motivos
Aplicações
Prós Contra
Pensamento e Programação
Sequencial

23. 23
Programar Paralelo é Díficil?

24. 24
Identificando Oportunidades de Paralelismo
● Estudar a aplicação:
● Tempo de execução
● Ferramentas de geração de profile
● Avaliar potênciais funções e loops
● Identificar tarefas que possam ser executadas concorrentemente
● Definir a maneira mais eficiente de paraleliza-lá
● Obter um código paralelo ideal pode levar horas, dias,
semanas e até meses

25. 25
1. Preparar a tinta = 30 s;
2. Pintar 300 estacas = 3000 s;
3. Aguardar tinta secar = 30 s;
Quanto tempo levará um pintor?
Exemplo

26. 26
1. Preparar a tinta = 30 s;
2. Pintar 300 estacas = 3000 s;
3. Aguardar tinta secar = 30 s;
Quanto tempo levará um pintor?
Exemplo
3060 s

27. 27
1. Preparar a tinta = 30 s;
2. Pintar 300 estacas = 3000 s;
3. Aguardar tinta secar = 30 s;
Quanto tempo levará um pintor?
Exemplo
3060 s
1530 s 1560 s
Quanto tempo levarão dois pintores?

28. 28
1. Preparar a tinta = 30 s;
2. Pintar 300 estacas = 3000 s;
3. Aguardar tinta secar = 30 s;
Quanto tempo levará um pintor?
Exemplo
3060 s
1530 s 1560 s
Quanto tempo levarão dois pintores?

29. 29
Exemplo
● Sempre existirão partes sequenciais em um programa!
1. Preparar a tinta
2. Pintar 300 estacas
3. Aguardar tinta secar
Região Paralela
Região Sequencial
Região Sequencial

30. 30
Exemplo
● Sempre existirão partes sequenciais em um programa!
1. Preparar a tinta
2. Pintar 300 estacas
3. Aguardar tinta secar
Região Paralela
Região Sequencial
Região Sequencial
Pintar 150
Secar a tinta
Preparar a tinta
Pintar 150
Pintar 300
Secar a tinta
Preparar a tinta
Tempo
Sequencial:
Tempo
Paralelo:

31. 31
Modelos de Programação Paralela
Memória Distribuída Memória Compartilhada

32. 32
● Open Multi-Processing
● Teve início por volta de 1997
● Padrão que define como os compiladores devem gerar códigos
paralelos através de diretivas e funções. (Não é linguagem!)
● Disponível para Fortran 77, Fortran 90, C e C++
● Baseia-se na criação de várias threads que compartilham o mesmo
recurso de memória
● Regiões Privadas
● Regiões Compartilhadas
Noções Básicas de OpenMP

33. 33
● Open Multi-Processing
● Teve início por volta de 1997
● Padrão que define como os compiladores devem gerar códigos
paralelos através de diretivas e funções. (Não é linguagem!)
● Disponível para Fortran 77, Fortran 90, C e C++
● Baseia-se na criação de várias threads que compartilham o mesmo
recurso de memória
● Regiões Privadas
● Regiões Compartilhadas
Noções Básicas de OpenMP

34. 34
● Facilidade de conversão de programas seqüenciais em paralelos
● Fácil compreensão e uso das diretivas
● Minimiza a interferência na estrutura do algoritmo
● Compila e executa em ambientes paralelo e sequencial
● Maneira simples de explorar o paralelismo
Noções Básicas de OpenMP

35. 35
● Facilidade de conversão de programas seqüenciais em paralelos
● Fácil compreensão e uso das diretivas
● Minimiza a interferência na estrutura do algoritmo
● Compila e executa em ambientes paralelo e sequencial
● Maneira simples de explorar o paralelismo
Noções Básicas de OpenMP
!!! CUIDADO !!!
OpenMP é simples, mas demanda conhecimento:
- Aplicação
- Arquitetura
- Melhor “opção” de paralelismo

36. 36
Modelo de Programação

37. 37
Elementos do OpenMP
#pragma omp diretiva [cláusula]
omp_serviço(...)OMP_NOME

38. 38
● Consiste em uma linha de código com significado especial para o
compilador.
● Identificadas pelo #pragma omp
● Formato padrão:
#pragma omp nome_diretiva [cláusula,...] novaLinha
● Inclusão header: “omp.h”
Diretivas de Compilação
Construtor Paralelo
Construtores de Compartilhamento de Trabalho
Diretivas de Sincronização

39. 39
● Diretiva mais importante do OpenMP
● Informa ao compilador a área que deverá ser executada em paralelo
Construtor Paralelo
#include <omp.h>
int main(){
#pragma omp parallel{
printf(“Ola Mundon”);
}
}
if, private, shared,
firstprivate, default,
copyin, reduction
num_threads

40. 40
● Exemplos:
● www.inf.ufrgs.br/~aflorenzon/curso_OpenMP/
● gcc nome_programa.c -o nome_saida -fopenmp
● hello.c e exemplo1.c
Construtor Paralelo
#include <omp.h>
int main(){
#pragma omp parallel
{
for(i=0;i<n;i++)
a[i] = b[i]+c[i];
}
}

41. 41
● Exemplos:
● www.inf.ufrgs.br/~aflorenzon/curso_OpenMP/
● gcc nome_programa.c -o nome_saida -fopenmp
● hello.c e exemplo1.c
Construtor Paralelo
#include <omp.h>
int main(){
#pragma omp parallel
{
for(i=0;i<n;i++)
a[i] = b[i]+c[i];
}
}
O que há de errado com
o código ao lado?

42. 42
● Exemplos:
● www.inf.ufrgs.br/~aflorenzon/curso_OpenMP/
● gcc nome_programa.c -o nome_saida -fopenmp
● hello.c e exemplo1.c
Construtor Paralelo
#include <omp.h>
int main(){
#pragma omp parallel
{
for(i=0;i<n;i++)
a[i] = b[i]+c[i];
}
}
O que há de errado com
o código ao lado?
Variáveis compartilhadas
entre todas as
threads, por padrão!

43. 43
● Exemplos:
● www.inf.ufrgs.br/~aflorenzon/curso_OpenMP/
● gcc nome_programa.c -o nome_saida -fopenmp
● hello.c e exemplo1.c
Construtor Paralelo
#include <omp.h>
int main(){
#pragma omp parallel private(i)
{
for(i=0;i<n;i++)
a[i] = b[i]+c[i];
}
}
Variáveis de controle
de laço devem ser
privadas à cada thread!

44. 44
● Construtor de Compartilhamento de Trabalho:
● Responsáveis pela distribuição de trabalho entre as threads e
determinam como o trabalho será dividido entre as threads.
● Necessariamente interna a uma região paralela.
#pragma omp construtor[clausula [clausula] …]
– #pragma omp for
– #pragma omp sections
– #pragma omp single
Construtor Paralelo

45. 45
● #pragma omp for
– Iterações dos laços for são executadas em paralelo.
– Número de iterações deve ser previamente conhecido e não
possui variação durante a execução – (while).
– Implementa SIMD (Single Instruction Multiple Data).
Construtor de Trabalho

46. 46
● #pragma omp for
– Iterações dos laços for são executadas em paralelo.
– Número de iterações deve ser previamente conhecido e não
possui variação durante a execução – (while).
– Implementa SIMD (Single Instruction Multiple Data).
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel private(i)
{
#pragma omp for
for(i=0;i<n;i++)
a[i] = b[i]+c[i];
}
}
Ex: ex_omp_for_1.c

47. 47
● #pragma omp for
– Schedulers alteram a forma como as iterações do loop são distribuídas
entre as threads
– #pragma omp for schedule (name_schedule, chunk)
– Guided, Dynamic, Static and Runtime
Construtor de Trabalho

48. 48
● Cláusula schedule:
Construtores de Trabalho
Ex:
ex_omp_for_static.c
ex_omp_for_dynamic.c
ex_omp_for_guided.c

49. 49
Intervalo
● Nos vemos novamente as 21:00 hs para a segunda etapa do curso!
● OpenMP Sections
● Diretivas de Sincronização
● Desafios Futuros
● Considerações Finais

50. 50
● #pragma omp sections
– Utilizado para dividir tarefas entre as threads em blocos de
códigos que não possuem iterações.
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp sections
{
#pragma omp section
instrução
#pragma omp section
instruçao
}
}
}

51. 51
● #pragma omp sections
– Utilizado para dividir tarefas entre as threads em blocos de
códigos que não possuem iterações.
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp sections
{
#pragma omp section
instrução
#pragma omp section
instruçao
}
}
}
Região paralela
Indica que cada thread
irá executar um bloco
de instruções diferentes
Qual instrução que cada
thread irá executar
Fim região paralela

52. 52
● #pragma omp sections
– Manter coerência entre número de blocos x número de threads
– Mais blocos → algumas threads irão executar mais de um bloco
– Mais threads → algumas threads ficarão ociosas
– Apenas uma thread → execução seqüencial
– Implementa MIMD (Multiple Instructions Multiple Data)
Construtor de Trabalho
Serial Paralelo

53. 53
● #pragma omp sections
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp sections
{
#pragma omp section
soma_vet(a,b,c);
#pragma omp section
mult_vet(a,b,d);
#pragma omp section
div_vet(a,b,e);
#pragma omp section
sub_vet(a,b,f);
}
}
}
Ex1: ex_omp_sections.cEx1: ex_omp_sections.c

54. 54
● #pragma omp sections
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp sections
{
#pragma omp section
soma_vet(a,b,c);
#pragma omp section
mult_vet(a,b,d);
#pragma omp section
div_vet(a,b,e);
#pragma omp section
sub_vet(a,b,f);
}
}
}
Ex1: ex_omp_sections.cEx1: ex_omp_sections.c
Ex1: ex_omp_sections.cEx2: ex_omp_sections_2.c
./ex_omp_sections_2 numero_threads
Ex1: ex_omp_sections.comp_set_num_threads(NUM)

55. 55
● #pragma omp single
● Trecho de código será executado apenas por uma thread
● Demais threads aguardam em uma barreira implícita
Construtor de Trabalho
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp single
printf(“Inicio região paralelan”);
#pragma omp for
…
}
}

56. 56
● Primeiro devemos entender o que são “condições de corrida”
● Quando duas ou mais threads tentam atualizar, ao mesmo tempo,
uma mesma variável
● Quando uma thread atualiza uma variável e outra acesso o valor ao
mesmo tempo
● Quando isto acontece, o resultado tende a ser incorreto!
Diretivas de Sincronização

57. 57
● Primeiro devemos entender o que são “condições de corrida”
● Quando duas ou mais threads tentam atualizar, ao mesmo tempo,
uma mesma variável
● Quando uma thread atualiza uma variável e outra acesso o valor ao
mesmo tempo
● Quando isto acontece, o resultado tende a ser incorreto!
Diretivas de Sincronização
Diretivas de sincronização garantem que o
acesso ou atualização de uma determinada variável
Compartilhada aconteça no momento certo

58. 58
● Construtores:
● Critical:
– Restringe a execução de uma determinada tarefa a apenas uma thread
por vez
● Atomic
● Barrier
Diretivas de Sincronização

59. 59
● Construtores:
● Critical:
– Restringe a execução de uma determinada tarefa a apenas uma thread
por vez
● Atomic:
– Um local específico da memória deve ser atualizado atomicamente, ao
invés de deixar várias threads tentarem escrever nele
– Em essência, esta directiva prevê uma seção mini-critical.
● Barrier
Diretivas de Sincronização

60. 60
● Construtores:
● Critical
● Atomic
● Barrier:
– Utilizada para sincronizar todas as threads em um determinado ponto
do código
Diretivas de Sincronização

61. 61
● Classificadas em:
● Funções de ambiente de execução
● Funções de bloqueio
● Funções de tempo
Funções de Interface

62. 62
● Paralelismo utilizando tasks!
● Utilizado para paralelizar algoritmos irregulares:
● Recursividade
● Repetições utilizando While
● Exemplos de aplicações:
● Algoritmos de ordenação → Merge sort, Quick sort...
● Manipulação de ponteiros → Listas
OpenMP Avançado

63. 63
● #pragma omp task
● Interna a uma região paralela
● Thread que executar o #pragma omp task criará uma nova task
OpenMP Avançado
#include <omp.h>
int main(){
#pragma omp parallel
{
#pragma omp single nowait
sort();
}
}
void sort(){
….
for(i=0;i<N;i++){
#pragma omp task
sort();
}
}

64. 64
● Poderosa API de programação paralela
● Fácil implementação
● Pouca modificação do código sequencial
● Bastante utilizada para computação hibrida (MPI + OpenMP)
Resumo OpenMP

65. 65
Desafios Futuros - Exascale

66. 66
Desafios Futuros – Eficiência Energética

67. 67
● Eficiência Energética
● Aumentar/Manter desempenho
● Diminuir o consumo de energia
● Arquiteturas Heterogêneas
Desafios Futuros

68. 68
● Eficiência Energética
● Aumentar/Manter desempenho
● Diminuir o consumo de energia
● Arquiteturas Heterogêneas
Desafios Futuros

69. 69
Desafios Futuros – Sistemas Embarcados
Multicore

70. 70
Limitações
● Sistemas alimentados por bateria
● Consumo de potência
● Paralelismo implica em compartilhamento
● Acesso a memória compartilhada
● Maior consumo de energia

71. 71
O que estamos pesquisando?
● Objetivo do trabalho:
● Prover framework para informar ao desenvolvedor qual o melhor
configuração que possui a melhor eficiência-energética.
– Acesso a memória compartilhada e privada
– Performance – speedup, eficiência, tempo...
– Diferentes cenários (Arq, API, threads, caract.)
● Comparar arquiteturas para propósito geral (Intel IA32) e arquiteturas
para sistemas embarcados (Intel Atom, ARM,...)
● Analisar diferentes interfaces de programação paralela (OpenMP,
Pthreads, Cilk++, MPI,...)

72. 72
Integrantes
● UFRGS:
● Antonio Carlos S. B. Filho
● Arthur F. Lorenzon
●
UNIPAMPA:
● Márcia C. Cera

73. 73
Integrantes
● UFRGS:
● Antonio Carlos S. B. Filho
● Arthur F. Lorenzon
●
UNIPAMPA:
● Márcia C. Cera
- O que necessito saber?
- Como fazer parte?
- Como fazer o Mestrado no grupo?
- Mais alguma pergunta?
Quero ser um integrante do projeto/LSE!

74. 74
Laboratório de Sistemas Embarcados - UFRGS
• Professores/Orientadores:
– Dr. Antonio Carlos S. B. Filho,
– Dr. Luigi Carro
– Dr. Flávio R. Wagner
• Doutorandos:
– Gabriel Luca Nazar – Tese defendida
– Ronaldo R. Ferreira
– Ulisses Brisolara Corrêa
• Mestrandos (Alunos Regulares):
– Andrws Aires Vieira
– Arthur Lorenzon
– Paulo Cesar Santos
– Thiago Santini
• ICs:
– Anderson, Jefferson...

75. 75
Laboratório de Sistemas Embarcados - UFRGS
• Cooperações Internacionais
Delft University Technology
Holanda
Politecnico Di Torino
Itália

76. Muito Obrigado!
Perguntas
gresslerbwg@gmail.com
marcia.cera@unipampa.edu.br
Arthur F. Lorenzon
Antonio Carlos S. B. F.
Henrique O. Gressler
Márcia C. Cera
aflorenzon@inf.ufrgs.br
caco@inf.ufrgs.br