MiniCurso Programação Paralela com OpenMP - SACTA 2013
Upcoming SlideShare
Loading in...5
×
 

MiniCurso Programação Paralela com OpenMP - SACTA 2013

on

  • 687 views

 

Statistics

Views

Total Views
687
Views on SlideShare
687
Embed Views
0

Actions

Likes
0
Downloads
21
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as OpenOffice

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • Out-of-Order
  • Out-of-Order
  • Out-of-Order
  • Out-of-Order

MiniCurso Programação Paralela com OpenMP - SACTA 2013 MiniCurso Programação Paralela com OpenMP - SACTA 2013 Presentation Transcript

  • Mini Curso: Programação Paralela utilizando OpenMP Arthur F. Lorenzon Antonio Carlos S. B. F. Henrique O. Gressler Márcia C. Cera
  • 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 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 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 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 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 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 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 Evolução dos Microprocessadores
  • 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 Evolução dos Microprocessadores Múltiplas Unidades Funcionais Hardware: Superscalar Software: VLIW
  • 12 Evolução dos Microprocessadores Melhora do desempenho utilizando técnicas de computação paralela!
  • 13 Evolução dos Microprocessadores Preocupação com gerenciamento de energia!!!
  • 14 Evolução dos Microprocessadores Paralelismo no Nível de Thread Aumento da Performance
  • 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 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 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 Programação Paralela “Programação Paralela é a capacidade de dividirmos uma carga de trabalho entre vários processadores dinamicamente e de forma eficiente!”
  • 19 O que paralelizar? ● Previsão do tempo e do clima ● Cálculos matemáticos ● Processamento de imagens ● Simuladores ● Componentes de Jogos*
  • 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 Cenário Atual Arquiteturas Multicore Ferramentas Motivos Aplicações Prós Contra
  • 22 Cenário Atual Arquiteturas Multicore Ferramentas Motivos Aplicações Prós Contra Pensamento e Programação Sequencial
  • 23 Programar Paralelo é Díficil?
  • 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 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 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 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 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 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 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 Modelos de Programação Paralela Memória Distribuída Memória Compartilhada
  • 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 ● 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 ● 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 ● 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 Modelo de Programação
  • 37 Elementos do OpenMP #pragma omp diretiva [cláusula] omp_serviço(...)OMP_NOME
  • 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 ● 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 ● 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 ● 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 ● 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 ● 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 ● 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 ● #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 ● #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 ● #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 ● Cláusula schedule: Construtores de Trabalho Ex: ex_omp_for_static.c ex_omp_for_dynamic.c ex_omp_for_guided.c
  • 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 ● #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 ● #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 ● #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 ● #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 ● #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 ● #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 ● 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 ● 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 ● Construtores: ● Critical: – Restringe a execução de uma determinada tarefa a apenas uma thread por vez ● Atomic ● Barrier Diretivas de Sincronização
  • 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 ● Construtores: ● Critical ● Atomic ● Barrier: – Utilizada para sincronizar todas as threads em um determinado ponto do código Diretivas de Sincronização
  • 61 ● Classificadas em: ● Funções de ambiente de execução ● Funções de bloqueio ● Funções de tempo Funções de Interface
  • 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 ● #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 ● 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 Desafios Futuros - Exascale
  • 66 Desafios Futuros – Eficiência Energética
  • 67 ● Eficiência Energética ● Aumentar/Manter desempenho ● Diminuir o consumo de energia ● Arquiteturas Heterogêneas Desafios Futuros
  • 68 ● Eficiência Energética ● Aumentar/Manter desempenho ● Diminuir o consumo de energia ● Arquiteturas Heterogêneas Desafios Futuros
  • 69 Desafios Futuros – Sistemas Embarcados Multicore
  • 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 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 Integrantes ● UFRGS: ● Antonio Carlos S. B. Filho ● Arthur F. Lorenzon ● UNIPAMPA: ● Márcia C. Cera
  • 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 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 Laboratório de Sistemas Embarcados - UFRGS • Cooperações Internacionais Delft University Technology Holanda Politecnico Di Torino Itália
  • 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