0
Programação Paralela e
      Distribuída
     ERAD-SP 2010

     31 de julho de 2010
    Liria Matsumoto Sato
    liria.sa...
Apresentação
• Introdução
• Arquiteturas Paralelas
• Programação Paralela para computadores com
  memória compartilhada
• ...
Introdução
Visão do Mundo atual:

• Crescimento contínuo da demanda por
  processamento
• Necessidade de compartilhamento ...
Introdução
Aplicações envolvendo grande capacidade de
  processamento:
• meteorologia
• simulação de fenômenos físicos
• v...
Figura extraída de www.top500.org.br (acesso em maio de 2010)

Demanda crescente →computadores mais potentes
Como obter alto desempenho

• Aumento do desempenho do processador
  • aumento do clock ⇒ aumento de temperatura
  • melho...
Processamento Paralelo
Utilização de múltiplos processadores

             P                    P


           Cache      ...
Processamento Paralelo
Paralelização da aplicação em múltiplas
 tarefas




        Tarefa1   Tarefa2   Tarefa3
Processamento Paralelo
      Paralelismo de dados


dados 1   dados 2   dados 3   dados 4 dados 5




 P1        P2       ...
Processamento Paralelo
Multi-core: multiplos núcleos no chip.
 AMD, INTEL: quad-core, hexa-core processor
       NEHALEN :...
Multi-core
• NEHALEM
Arquitetura CELL




Extraído de http://www.research.ibm.com/cell/heterogeneousCMP.html
GPU




Geforce 8800 GTX [figura extraída de ¨Programming Massively Parallel
Processors: a hands-on Aproach. David B. Kirk...
Processadores GPU
nVIDIA Tesla S1070: 4 GPUs
4 TFlops (ponto flutuante precisão simples)
345 Gflops (ponto flutuante preci...
Arquiteturas Paralelas
Arquiteturas Paralelas: caracterizadas pela
  presença de múltiplos processadores que
  cooperam en...
Arquiteturas Paralelas
       Multiprocessadores


        memória compartilhada




P1        P2          P3        P4


...
Arquiteturas Paralelas
             Cluster


    Switch             LAN
    10GbE
Aplicação
• Como paralelizar
• Como programar
Linguagens e compiladores específicos:
- multi-core, multiprocessadores: Ope...
Desenvolvimento de aplicações
Definir solução com processamento paralelo:
• Paralelização de sequências de instruções
• Pa...
Exemplo com paralelização de
              laços
#pragma pfor iterate (i=0;          forall i = 0 to MAXRET      {
MAXRET;...
Programação paralela para
       sistemas com memória
            compartilhada
Sistemas com memória compartilhada:
• comp...
Paralelização de seqüências de
            instruções

• Múltiplas tarefas simultâneas: macrotarefas
• Paralelização do pr...
Múltiplas tarefas simultâneas


            tarefa1      tarefa2      tarefa3




 Macrotarefas: são procedimentos especia...
Macrotarefas
#include <stdio            task body tarefa2()
task spec tarefa1();       { int i;
task spec tarefa2();      ...
Macrotarefas
main()
{ printf(“INICIO TESTEn”);
   alloc_proc(4);
   create 1,tarefa1();
   create 1,tarefa2();
   create 1...
Paralelização da função principal
blocos paralelos na função principal
  cada bloco:
  – Blocos
  – Tarefas
  – Elementos ...
“seq1”



tar1    tar2         tar3   tar4


       “seq2”


tar5   tar6                 “seq3”
Blocos Paralelos (CPAR)
• comando cobegin ... also ... coend
• restrição: presente apenas na função
  main()
   main()
   ...
sincronização de tarefas
• espera pelo término de uma tarefa
     wait_task(nome_tarefa);
     exemplo: wait_proc(tarefa1)...
Laços Paralelos: Paralelismo
       homogêneo

   forall i=1 to max{
     a[i]=b[i]+1;
     c[i]=c[i]+a[i];
   }
CPAR: laç...
Exemplo
#include <stdio.h>         task body tarefa2()
task spec tarefa1();       {int i;
task spec tarefa2();        for(...
Paralelismo heterogêneo
  parbegin
   a=a+sqr(b);
   x=x*2;
  also
  c=c+sqr(c);
  y=y+1;
  parend

CPAR: blocos paralelos...
memória compartilhada
Cada processo pode ter uma porção de
 memória privada.
Algumas locações de memória podem ser:
  • ac...
memória compartilhada
O sistema CPAR permite o uso de:
· variáveis privadas (locais)
· variáveis compartilhadas:
        s...
Laço Paralelo: exemplo
                iniciação de uma matriz
#include <stdio.h>            main()
shared float a[1000][1...
Laço Paralelo
• CPAR: iterações são particionadas
  uniformemente (pré-scheduling)
• pré-compilador: gera código para trat...
Exclusão Mútua
Processamento exclusivo de processos é necessário
  para que recursos possam ser compartilhados sem
  inter...
Exclusão mútua
Se 2 processos executarem esta seqüência, pode
  ocorrer:

LD COUNT      {processo 1}
LD COUNT      {proces...
Exclusão mútua

Seção crítica: seqüência de códigos executada
  ininterruptamente, garantindo que estados
  inconsistentes...
Semáforos
Em CPAR:
declaração de semáforo: global ou local a
  macrotarefa
shared Semaph nome_semaforo;
Ex: shared Semaph ...
Semáforo Binário
shared Semaph X;

create_sem(&X,1);

lock(&X);

unlock(&X);

rem_sem(&X);
Exemplo: seção crítica
task body tarefa()
{shared Semaph A;
 int i;
 create_sem(&A,1);
 forall i=0 to 99
   { ....
      l...
Threads
• thread: é um fluxo de controle seqüencial
  em um programa.
• programação multi-threaded: uma forma
  de program...
multi-threaded X multi-processing
• multi-threaded programming: todos os
  threads compartilham o mesmo espaço de
  memóri...
Pthreads
• POSIX : Pthreads
• Exemplo: pi-pthreads.c
• Compilação:
gcc –o pi-pthreads pi-pthreads.c -lpthread
OpenMP
• spec25.pdf : www.openmp.org/mp-
  documents/spec25.pdf
• Diretivas
#pragma omp directive-name [clause[ [,] clause...
pi - openmp
int main()
{
.....
omp_set_num_threads(4);
#pragma omp parallel shared (total_pi,largura) private(i,x,local_pi...
pi-openmp-reduction
omp_set_num_threads(4);
#pragma omp parallel shared (largura) private(i,x) reduction(+:y)
{
#pragma om...
omp-section
 omp_set_num_threads(2);
#pragma omp parallel sections
  {
#pragma omp section
  { printf("secao 1n");
    for...
Sistemas Distribuídos
• Não possui memória compartilhada
• Bibliotecas: PVM, MPI
• Sistemas DSM (distributed shared
  memo...
Sistemas Distribuídos:
  Programação com bibliotecas
• PVM (parallel virtual machine)
• MPI (message passage interface)
• ...
Modelo de computação: spmd
   (single program multiple data)

• todos os nós executam o mesmo
  programa sobre dados múlti...
modelo de computação:
  esquema mestre escravo com
            spmd
• esquema mestre-escravo utilizando spmd:
  todos exec...
Modelo de computação

                  Mestre




escravo 1   escravo 2       escravo N




                   Mestre
Grupos de tarefas
                                        Mestre




                                      escravo 2      ...
Exemplo : Soma dos elementos
         de um vetor

                   Processo Mestre




    escravo 1   escravo 2       ...
Para obter um bom desempenho

• Use granularidade grossa

• minimize o # de mensagens

• maximize o tamanho de cada mensag...
MPI



OPEN MPI
http://www.open-mpi.org/
MPI
• Processos: são representados por um único
  “rank”(inteiro) e ranks são numerados 0, 1, 2
  ..., N-1. (N = total de ...
Programa MPI - SPMD
#include <mpi.h>
........

main(argc, argv)
int            argc;
char                   *argv[];
{
   ...
Programa MPI - SPMD
if (0 == rank)           // rank = 0
     {
        ..........

     }
    else                 // ran...
MPI

• Enviando Mensagens
MPI_Send(void *buf,int count,MPI_Datatype
  dtype,int dest,int tag,MPI_Comm comm);
• Recebendo M...
Exemplo: enviando mensagens
// rank 0, send a message to rank 1.
    if (0 == rank) {
          for (i=0;i<64;i++)
       ...
MPI – compilação e execução
• Compilação (openmpi)
mpicc -o trivial trivial.c
mpiCC –o trivial trivial.cpp

execução: mpir...
Comunicação
• Comunicação ponto a ponto: uma
  origem e um destino
  – Envio bloqueante
  – Recepção bloqueante
  – Envio ...
Envio Padrão Bloqueante
• O comportamento do sistema depende do
  tamanho da mensagem, se é menor ou igual
  ou maior do q...
Envio Padrão Bloqueante
• mensagem>limite

  MPI_Send
             espera



                           espera
           ...
Programação: modelo mestre-escravo em SPMD

void main()
int     argc;
char *argv[];
{ int myrank;
   MPI_Init(&argc,&argv)...
Exemplo: soma de elementos de
    um vetor (MPI_Send)
k=n/n_nos;
    inicio=rank*k;
    fim=inicio+k;
    if (rank==0) {
 ...
Exemplo: soma de elementos de
       um vetor (MPI_Send)
if (rank==0) {
        soma_total=soma_parcial;
        for(i=1;i...
Envio Bloqueante
• Padrão:
MPI_Send(&buf,n_elementos,MPI_INT,dest, tag,
 MPI_COMM_WORLD)
• Blocking Syncronous Send :
MPI_...
Envio Bloqueante
• Blocking Ready Send
MPI_Rsend (&buf,n_elementos,MPI_INT,
dest, tag, MPI_COMM_WORLD)
• envia a mensagem ...
Envio Bloqueante
• Blocking Buffered Send
MPI_Bsend(&buf,n_elementos,MPI_INT,
dest, tag, MPI_COMM_WORLD )
• Aplicação deve...
Recepção Bloqueante
• MPI_Recv(&a,10,MPI_INT,origem,tag,MPI
  _COMM_WORLD,&status)
  bloqueante: receptor fica bloqueado a...
Recepção: outras funções
• MPI_Probe(in source,int tag,MPI_Comm
  comm,MPI_Status *status)
  Sincroniza uma mensagem e ret...
Funções de comunicação não
       bloqueantes

• chamadas não bloqueantes retornam
  imediatamente após o início da
  comu...
Comunicação não bloqueante
• envio: retorna após colocar o dado no
  buffer de envio.
MPI_Isend(void *buf,int count,MPI_Da...
Comunicação não bloqueante
• Recepção: é dado o início à operação de
  recepção e retorna.
MPI_Irecv(void *buf, count,MPI_...
Comunicação não bloqueante
MPI_Wait(MPI_Request *req,MPI_Status *status)
Espera completar a transmissão ou a recepção.
MPI...
Comunicação não bloqueante
if (rank==0) {
 ............

MPI_Isend(&a[0][0]+(k*n*i),k*n,MPI_DOUBLE,i,10,MPI_COMM_WO
RLD,&r...
Comunicação coletiva

MPI_Bcast(void *buf,int count,MPI_Datatype
  dtype,int root,MPI_Comm comm);
• todos processos execut...
Comunicação coletiva
MPI_Scatter(void *sendbuf,int sendcount,
MPI_Datatype sendtype,void *recvbuf,
int recvcount,MPI_Datat...
Comunicação coletiva
MPI_Gather(void *sendbuf,int
 sendcount,MPI_Datatype sendtype,void
 *recvbuf,int recvcount,MPI_Dataty...
Exemplo: MPI_Scatter
if (rank==0) {
        for(i=0;i<n;i++)
         for(j=0;j<n;j++)
           a[i][j]=1;
      }
   MP...
Comunicação coletiva
• MPI_Reduce(void *sendbuf,void *recvbuf,int
  count,MPI_Datatype dtype,MPI_Op op,int
  root,MPI_Comm...
Exemplo: MPI_Reduce

k=n/n_nos;
MPI_Scatter(a,k*n,MPI_DOUBLE,a,k*n,MPI_DOUBLE,0,M
   PI_COMM_WORLD); // rank 0: root
parci...
Aplicação
Projeto OpenModeller
Objetivo: construir uma versão eficiente da
 ferramenta OpenModeller para predizer a
 distr...
Biodiversidade

• Mapa de distribuição da espécie
OpenModeller
Duas etapas:
• Modelagem: modelagem da presença da
  espécie considerando condições
  climáticas e geográfica...
Biodiversidade
• Experimento:
  – Predição da distribuição de uma espécie para
    um conjunto de camadas ambientais corta...
experimento
Estratégia de paralelização

               Nó 1 result..
 Solicita                           Nó 0
 bloco
            Info...
Biodiversidade
                    •Tempo de execução sequencial: 66 min.
                    •Tempo de execução da projeç...
Conclusão
Impacto da computação de alto desempenho
  nas áreas da computação
• Novas ferramentas de programação
• Metodolo...
Conclusão
Pesquisas
• construção de grids para processamento
  paralelo
   – MPI utilizando múltiplos clusters e
     serv...
Bibliografia
1. Ben-Ari, M. "Principles of Concurrent and Distributed
   Programming", Addison-Wesley, Second Edition, 200...
Upcoming SlideShare
Loading in...5
×

Mini-curso Programação Paralela e Distribuída

6,722

Published on

Mini-curso do ERAD-SP

Published in: Education
0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
6,722
On Slideshare
0
From Embeds
0
Number of Embeds
1
Actions
Shares
0
Downloads
200
Comments
0
Likes
2
Embeds 0
No embeds

No notes for slide

Transcript of "Mini-curso Programação Paralela e Distribuída"

  1. 1. Programação Paralela e Distribuída ERAD-SP 2010 31 de julho de 2010 Liria Matsumoto Sato liria.sato@poli.usp.br
  2. 2. Apresentação • Introdução • Arquiteturas Paralelas • Programação Paralela para computadores com memória compartilhada • Programação paralela para sistemas distribuídos • Conclusão Ferramentas: CPAR e MPI Download CPAR e exemplos de programas: http://regulus.pcs.usp.br/~lms/eradsp.html
  3. 3. Introdução Visão do Mundo atual: • Crescimento contínuo da demanda por processamento • Necessidade de compartilhamento de Informação e de recursos • Acesso a recursos computacionais de alto desempenho Computação de alto desempenho: busca de soluções
  4. 4. Introdução Aplicações envolvendo grande capacidade de processamento: • meteorologia • simulação de fenômenos físicos • visualização científica • modelagem das variações climáticas globais em longos períodos • genoma humano • dinâmica de fluídos • Estrutura e Dinâmica molecular
  5. 5. Figura extraída de www.top500.org.br (acesso em maio de 2010) Demanda crescente →computadores mais potentes
  6. 6. Como obter alto desempenho • Aumento do desempenho do processador • aumento do clock ⇒ aumento de temperatura • melhorias na arquitetura • Processamento Paralelo: • Múltiplas unidades de processamento • Paralelização da aplicação
  7. 7. Processamento Paralelo Utilização de múltiplos processadores P P Cache Cache Memória global
  8. 8. Processamento Paralelo Paralelização da aplicação em múltiplas tarefas Tarefa1 Tarefa2 Tarefa3
  9. 9. Processamento Paralelo Paralelismo de dados dados 1 dados 2 dados 3 dados 4 dados 5 P1 P2 P3 P4 P5
  10. 10. Processamento Paralelo Multi-core: multiplos núcleos no chip. AMD, INTEL: quad-core, hexa-core processor NEHALEN : quad-core, hexa-core IBM: CELL NVIDIA, ATI: GPUs (Graphics Processing Unit) Computadores com arquitetura paralela
  11. 11. Multi-core • NEHALEM
  12. 12. Arquitetura CELL Extraído de http://www.research.ibm.com/cell/heterogeneousCMP.html
  13. 13. GPU Geforce 8800 GTX [figura extraída de ¨Programming Massively Parallel Processors: a hands-on Aproach. David B. Kirk; Wen-mei Hwu. Elsevier Inc.
  14. 14. Processadores GPU nVIDIA Tesla S1070: 4 GPUs 4 TFlops (ponto flutuante precisão simples) 345 Gflops (ponto flutuante precisão dupla) 4 GB memória dedicada
  15. 15. Arquiteturas Paralelas Arquiteturas Paralelas: caracterizadas pela presença de múltiplos processadores que cooperam entre si na execução de um programa. Década 1960 : ILLIAC IV (SIMD) SIMD: todos os processadores executam a mesma instrução sobre dados distintos MIMD: os processadores podem executar instruções distintas sobre dados distintos – Multiprocessadores – Multicomputadores: clusters
  16. 16. Arquiteturas Paralelas Multiprocessadores memória compartilhada P1 P2 P3 P4 M M M M
  17. 17. Arquiteturas Paralelas Cluster Switch LAN 10GbE
  18. 18. Aplicação • Como paralelizar • Como programar Linguagens e compiladores específicos: - multi-core, multiprocessadores: OpenMP, CPAR memória compartilhada - clusters: memória distribuída: MPI (Message Passage Interface): - diversas implementações disponíveis MPICH, OPENMPI
  19. 19. Desenvolvimento de aplicações Definir solução com processamento paralelo: • Paralelização de sequências de instruções • Paralelização de laços • Algumas aplicações exigem soluções mais complexas: – Partes da aplicação envolvem cálculos dependentes de cálculos anteriores – Partes da aplicação exigem uma ordenação na geração de resultados
  20. 20. Exemplo com paralelização de laços #pragma pfor iterate (i=0; forall i = 0 to MAXRET { MAXRET; 1) x = ((i-0.5) * largura); for (i = 0; i < MAXRET; i++) /* calcula x */ { x = ((i-0.5) * largura); local_pi=local_pi+(4.0/(1.0+ /* calcula x */ x* x)); local_pi = local_pi + (4.0 / ( local_pi = local_pi * 1.0 + x * x)); largura; } lock (&semaforo); local_pi = local_pi * largura; total_pi = total_pi + #pragma critical local_pi; { unlock (&semaforo); total_pi = total_pi + local_pi; } } }
  21. 21. Programação paralela para sistemas com memória compartilhada Sistemas com memória compartilhada: • computadores multiprocessadores (processadores multicore ou não) • Computadores com processador multicore. Ferramenta didática: linguagem CPAR – Extensão da linguagem C
  22. 22. Paralelização de seqüências de instruções • Múltiplas tarefas simultâneas: macrotarefas • Paralelização do programa em blocos paralelos • Laços e blocos paralelos • CPAR: – Múltiplas tarefas simultâneas – laços e blocos paralelos dentro de uma tarefa – Blocos paralelos na função main
  23. 23. Múltiplas tarefas simultâneas tarefa1 tarefa2 tarefa3 Macrotarefas: são procedimentos especiais Tempo execução seqüencial=ttarefa1 + ttarefa2 + ttarefa3 Tempo execução paralela=max(ttarefa1 , ttarefa2 , ttarefa3)
  24. 24. Macrotarefas #include <stdio task body tarefa2() task spec tarefa1(); { int i; task spec tarefa2(); for (i=0;i<199;i++) task spec tarefa3(); { printf(“%c”,’b’); task body tarefa1() fflush(stdout);} { int i; } for (i=0;i<199;i++) task body tarefa3() { printf(“%c”,’a’); { int i; fflush(stdout); for (i=0;i<199;i++) } {printf(“%c”,’c’); } fflush(stdout);}
  25. 25. Macrotarefas main() { printf(“INICIO TESTEn”); alloc_proc(4); create 1,tarefa1(); create 1,tarefa2(); create 1,tarefa3(); }
  26. 26. Paralelização da função principal blocos paralelos na função principal cada bloco: – Blocos – Tarefas – Elementos Seqüenciais bloco 1 bloco 1 bloco 2 bloco 3 bloco 1a bloco 1b bloco 1c blocos paralelos
  27. 27. “seq1” tar1 tar2 tar3 tar4 “seq2” tar5 tar6 “seq3”
  28. 28. Blocos Paralelos (CPAR) • comando cobegin ... also ... coend • restrição: presente apenas na função main() main() { ... cobegin ..... also ...... also ....... coend ...... }
  29. 29. sincronização de tarefas • espera pelo término de uma tarefa wait_task(nome_tarefa); exemplo: wait_proc(tarefa1); • espera pelo término de todas tarefas em execução wait_all()
  30. 30. Laços Paralelos: Paralelismo homogêneo forall i=1 to max{ a[i]=b[i]+1; c[i]=c[i]+a[i]; } CPAR: laços paralelos internos a uma macrotarefa
  31. 31. Exemplo #include <stdio.h> task body tarefa2() task spec tarefa1(); {int i; task spec tarefa2(); for(i=0;i<10;i++) {printf("%c",'b'); task body tarefa1() fflush(stdout); {int i; } for(i=0;i<10;i++) } {printf("%c",'a'); main() fflush(stdout); {printf("INICIO TESTEn"); } alloc_proc(2); } create 1,tarefa1(); wait_task(tarefa1); create 1,tarefa2(); }
  32. 32. Paralelismo heterogêneo parbegin a=a+sqr(b); x=x*2; also c=c+sqr(c); y=y+1; parend CPAR: blocos paralelos dentro de uma macrotarefa
  33. 33. memória compartilhada Cada processo pode ter uma porção de memória privada. Algumas locações de memória podem ser: • acessadas por 2 ou mais processos, referenciadas no programa através de variáveis compartilhadas, promovendo a comunicação entre os processos.
  34. 34. memória compartilhada O sistema CPAR permite o uso de: · variáveis privadas (locais) · variáveis compartilhadas: shared int A; - Variáveis compartilhadas entre macrotarefas declaração na área de declarações de variáveis globais - Variáveis compartilhadas pelas microtarefas de uma macrotarefa declaração na área de declarações de variáveis da macrotarefa
  35. 35. Laço Paralelo: exemplo iniciação de uma matriz #include <stdio.h> main() shared float a[1000][1000]; { alloc_proc(4); task spec inic_mat(); printf(“inicia matrizn”): task body inic_mat() create 4,inic_mat(); {int i,j; wait_proc(inic_mat); forall i=0 to 999 printf(“iniciacao { efetuadan”); for(j=0;j<1000;j++) } a[i][j]=i+2*j; } }
  36. 36. Laço Paralelo • CPAR: iterações são particionadas uniformemente (pré-scheduling) • pré-compilador: gera código para tratar o particionamento • em outros sistemas: self-scheduling (distribuiçao dinâmica de blocos de tamanho definido), guided self-scheduling (similar ao self-scheduling, com calculo dinâmico do tamanho dos blocos)
  37. 37. Exclusão Mútua Processamento exclusivo de processos é necessário para que recursos possam ser compartilhados sem interferências mútuas. Exemplo: Em um programa um contador (COUNT) é compartilhado e incrementado por mais de um processo. COUNT = COUNT + 1 LD COUNT ADD 1 STO COUNT
  38. 38. Exclusão mútua Se 2 processos executarem esta seqüência, pode ocorrer: LD COUNT {processo 1} LD COUNT {processo 2} ADD 1 {processo 2} STO COUNT {processo 2} ADD 1 {processo 1} STO COUNT {processo 1} COUNT: incrementado apenas de 1. Solução: encerrar a seqüência de instruções em uma seção crítica.
  39. 39. Exclusão mútua Seção crítica: seqüência de códigos executada ininterruptamente, garantindo que estados inconsistentes de um dado processo não sejam visíveis aos restantes. Isto é realizado utilizando mecanismos de exclusão mútua. exclusão mútua: implementação com semáforos binários
  40. 40. Semáforos Em CPAR: declaração de semáforo: global ou local a macrotarefa shared Semaph nome_semaforo; Ex: shared Semaph X; criação : create_sem(&nome_semafor,valor_inicial); Ex: create_sem(&X,1); remoção: rem_sem(&nome_semaforo); Ex: rem_sem(&X); operação P: lock(&nome_semaforo); Ex: lock(&X); operação V: unlock(&nome_semaforo); Ex: unlock(&X);
  41. 41. Semáforo Binário shared Semaph X; create_sem(&X,1); lock(&X); unlock(&X); rem_sem(&X);
  42. 42. Exemplo: seção crítica task body tarefa() {shared Semaph A; int i; create_sem(&A,1); forall i=0 to 99 { .... lock(&A); COUNT=COUNT+1; unlock(&A); ..... } ...... rem_sem(&A); }
  43. 43. Threads • thread: é um fluxo de controle seqüencial em um programa. • programação multi-threaded: uma forma de programação paralela onde vários threads são executados concorrentemente em um programa. Todos threads executam em um mesmo espaço de memória, podendo trabalhar concorrentemente sobre dados compartilhados.
  44. 44. multi-threaded X multi-processing • multi-threaded programming: todos os threads compartilham o mesmo espaço de memória e alguns outros recursos, como os descritores de arquivos. • multi-processing: processos executam sobre seu próprio espaço de memória. O compartilhamento de dados se obtém através de funções que fazem com que endereços lógicos apontem para o mesmo endereço físico.
  45. 45. Pthreads • POSIX : Pthreads • Exemplo: pi-pthreads.c • Compilação: gcc –o pi-pthreads pi-pthreads.c -lpthread
  46. 46. OpenMP • spec25.pdf : www.openmp.org/mp- documents/spec25.pdf • Diretivas #pragma omp directive-name [clause[ [,] clause]...] new-line Região paralela: #pragma omp parallel Compilação: gcc –o pi-openmp pi-openmp.c -fopenmp icc –o pi-openmp pi-openmp.c -openmp Exemplos: pi-openmp.c Seções: omp-section.c Redução: pi-openmp-reduction.c
  47. 47. pi - openmp int main() { ..... omp_set_num_threads(4); #pragma omp parallel shared (total_pi,largura) private(i,x,local_pi) { #pragma omp for for (i = 0; i < MAXRET; i++) { x = ((i-0.5) * largura); /* calcula x */ local_pi = local_pi + (4.0 / ( 1.0 + x * x)); } local_pi = local_pi * largura; printf("LOCAL-PI %lfn",local_pi); #pragma omp critical { total_pi = total_pi + local_pi; ..... }
  48. 48. pi-openmp-reduction omp_set_num_threads(4); #pragma omp parallel shared (largura) private(i,x) reduction(+:y) { #pragma omp for for (i = 0; i < MAXRET; i++) { x = ((i-0.5) * largura); /* calcula x */ y = y + (4.0 / ( 1.0 + x * x)); } } total_pi = y * largura; printf("TOTAL-PI %lfn",total_pi); }
  49. 49. omp-section omp_set_num_threads(2); #pragma omp parallel sections { #pragma omp section { printf("secao 1n"); for (i=0;i<20000;i++) {printf("a"); fflush(stdout); } } #pragma omp section { printf("secao 2n"); for (i=0;i<20000;i++) {printf("b"); fflush(stdout); } } }
  50. 50. Sistemas Distribuídos • Não possui memória compartilhada • Bibliotecas: PVM, MPI • Sistemas DSM (distributed shared memory): simula memória compartilhada, permitindo a programação no paradigma de variáveis compartilhadas
  51. 51. Sistemas Distribuídos: Programação com bibliotecas • PVM (parallel virtual machine) • MPI (message passage interface) • programação utilizando passagem de mensagem
  52. 52. Modelo de computação: spmd (single program multiple data) • todos os nós executam o mesmo programa sobre dados múltiplos 0 .....9 10...19 20....29 nó 1 nó 2 nó 3
  53. 53. modelo de computação: esquema mestre escravo com spmd • esquema mestre-escravo utilizando spmd: todos executam o mesmo programa, sendo que através de um controle interno ao programa um nó executa a função mestre eos demais são escravos.
  54. 54. Modelo de computação Mestre escravo 1 escravo 2 escravo N Mestre
  55. 55. Grupos de tarefas Mestre escravo 2 Mestre Mestre escravo escravo escravo 1 escravo 2 escravoN Mestre Mestre Tarefa Mestre Grupo de Tarefas
  56. 56. Exemplo : Soma dos elementos de um vetor Processo Mestre escravo 1 escravo 2 escravo N
  57. 57. Para obter um bom desempenho • Use granularidade grossa • minimize o # de mensagens • maximize o tamanho de cada mensagem • use alguma forma de Balanceamento de carga
  58. 58. MPI OPEN MPI http://www.open-mpi.org/
  59. 59. MPI • Processos: são representados por um único “rank”(inteiro) e ranks são numerados 0, 1, 2 ..., N-1. (N = total de processos) • Enter e Exit MPI_Init(int *argc,char *argv); MPI_Finalize(void); • Quem eu sou? MPI_Comm_rank(MPI_Comm comm,int *rank); • informa total de processos MPI_Comm_size(MPI_Comm comm,int *size);
  60. 60. Programa MPI - SPMD #include <mpi.h> ........ main(argc, argv) int argc; char *argv[]; { int size, rank; MPI_Status status; ....... // Initialize MPI. MPI_Init(&argc, &argv); ......... MPI_Comm_size(MPI_COMM_WORLD, &size); MPI_Comm_rank(MPI_COMM_WORLD, &rank); ......
  61. 61. Programa MPI - SPMD if (0 == rank) // rank = 0 { .......... } else // rank > 0 { ........... } MPI_Finalize(); return(0); }
  62. 62. MPI • Enviando Mensagens MPI_Send(void *buf,int count,MPI_Datatype dtype,int dest,int tag,MPI_Comm comm); • Recebendo Mensagens MPI_Recv(void *buf,int count,MPI_Datatype dtype,int source,int tag,MPI_Comm comm,MPI_Status *status); status: status.MPI_TAG status.MPI_SOURCE
  63. 63. Exemplo: enviando mensagens // rank 0, send a message to rank 1. if (0 == rank) { for (i=0;i<64;i++) buf[i]=i; MPI_Send(buf, BUFSIZE, MPI_INT, 1, 11, MPI_COMM_WORLD); } // rank 1, receive a message from rank 0. else { MPI_Recv(buf, BUFSIZE, MPI_INT, 0, 11, MPI_COMM_WORLD, &status); for(i=0;i<64;i++) { printf("%d",buf[i]); fflush(stdout);} printf("n"); }
  64. 64. MPI – compilação e execução • Compilação (openmpi) mpicc -o trivial trivial.c mpiCC –o trivial trivial.cpp execução: mpirun -np 2 –hosts trivial hosts: arquivo contendo os IPs ou nomes dos nós
  65. 65. Comunicação • Comunicação ponto a ponto: uma origem e um destino – Envio bloqueante – Recepção bloqueante – Envio não bloqueante – Recepção não bloqueante • Comunicação Coletiva
  66. 66. Envio Padrão Bloqueante • O comportamento do sistema depende do tamanho da mensagem, se é menor ou igual ou maior do que um limite. Este limite é definido pela implementação do sistema e do número de tarefas na aplicação. • mensagem<= limite MPI_Send S R buffer interno do receptor MPI_Recv
  67. 67. Envio Padrão Bloqueante • mensagem>limite MPI_Send espera espera MPI_Revc
  68. 68. Programação: modelo mestre-escravo em SPMD void main() int argc; char *argv[]; { int myrank; MPI_Init(&argc,&argv); MPI_Comm_rank(MPI_COMM_WORLD,&myrank); if (myrank==0) {master();} else { slave();} MPI_Finalize(); return(0); }
  69. 69. Exemplo: soma de elementos de um vetor (MPI_Send) k=n/n_nos; inicio=rank*k; fim=inicio+k; if (rank==0) { for(i=inicio;i<n;i++) vetor[i]=1; for (i=1;i<n_nos;i++) MPI_Send(vetor+k*i,k,MPI_INT,i,10,MPI_COMM_WORLD); } else { MPI_Recv(vetor,k,MPI_INT,0,10,MPI_COMM_WORLD,&status); } soma_parcial=0; for(i=0;(i<k);i++) soma_parcial+=vetor[i];
  70. 70. Exemplo: soma de elementos de um vetor (MPI_Send) if (rank==0) { soma_total=soma_parcial; for(i=1;i<n_nos;i++){ MPI_Recv(&soma,1,MPI_INT,MPI_ANY_SOURCE,11, MPI_COMM_WORLD,&status); soma_total+=soma;} } else { MPI_Send(&soma_parcial,1,MPI_INT,0,11,MPI_COMM_WORLD); } MPI_Finalize(); return(0);
  71. 71. Envio Bloqueante • Padrão: MPI_Send(&buf,n_elementos,MPI_INT,dest, tag, MPI_COMM_WORLD) • Blocking Syncronous Send : MPI_Ssend (&buf,n_elementos,MPI_INT, dest, tag, MPI_COMM_WORLD) • tarefa transmissora: envia para a tarefa receptora uma mensagem “ready to send”. • tarefa receptora: ao executar uma chamada receive, envia para a tarefa transmissora uma mensagem de “ready to receive”. • Os dados são transferidos.
  72. 72. Envio Bloqueante • Blocking Ready Send MPI_Rsend (&buf,n_elementos,MPI_INT, dest, tag, MPI_COMM_WORLD) • envia a mensagem na rede. • Requer que uma notificação de “ready to receive” tenha chegado. • Notificação não recebida: erro.
  73. 73. Envio Bloqueante • Blocking Buffered Send MPI_Bsend(&buf,n_elementos,MPI_INT, dest, tag, MPI_COMM_WORLD ) • Aplicação deve prover o buffer: array alocado estaticamente ou dinamicamente com malloc. Deve ser incluido bytes do header. • MPI_Buffer_attach( ... ) • Dados do buffer de mensagem copiados para buffer do usuário. Execução retorna. • O dado será copiado do buffer do usuário sobre a rede quando uma notificação de “ready to receive”tiver chegado • MPI_Buffer_detach( ... )
  74. 74. Recepção Bloqueante • MPI_Recv(&a,10,MPI_INT,origem,tag,MPI _COMM_WORLD,&status) bloqueante: receptor fica bloqueado até receber a mensagem. tag: pode ser MPI_ANY_TAG (qualquer tag) origem: pode ser MPI_ANY_SOURCE (qualquer origem) status: 2 campos status.source: origem da mensagem status.tag: tag da mensagem
  75. 75. Recepção: outras funções • MPI_Probe(in source,int tag,MPI_Comm comm,MPI_Status *status) Sincroniza uma mensagem e retorna informações. Não retorna até que uma mensagem seja sincronizada. • MPI_Get_count(MPI_Status *status,MPI_Data type dtype,int *count) Retorna o número de elementos da mensagem recebida. uso: quando não se conhece o tamanho da mensagem a ser recebida. Mensagem sincronizada com MPI_Probe.
  76. 76. Funções de comunicação não bloqueantes • chamadas não bloqueantes retornam imediatamente após o início da comunicação. O programador não sabe se o dado enviado já saiu do buffer de envio ou se o dado a ser recebido já chegou. Então, o programador deve verificar o seu estado antes de usar o buffer.
  77. 77. Comunicação não bloqueante • envio: retorna após colocar o dado no buffer de envio. MPI_Isend(void *buf,int count,MPI_Datatype dtype,int dest,int tag,MPI_Comm comm,MPI_Request *req) req: objeto que contém informações sobre a mensagem, por exemplo o estado da mensagem.
  78. 78. Comunicação não bloqueante • Recepção: é dado o início à operação de recepção e retorna. MPI_Irecv(void *buf, count,MPI_INT, origem, tag, MPI_Comm comm, MPI_Request *req) • Dados: não devem ser lidos enquanto não estiverem disponíveis Verificação: MPI_Wait ou MPI_Test.
  79. 79. Comunicação não bloqueante MPI_Wait(MPI_Request *req,MPI_Status *status) Espera completar a transmissão ou a recepção. MPI_Test(MPI_Request *req,int *flag,MPI_Status *status) Retorna em flag a indicação se a transmissão ou recepção foi completada. Se true, o argumento status está preenchido com informação MPI_Iprobe(int source,int tag,MPI_Comm comm,int *flag,MPI_Status *status) Seta flag, indicando a presença do casamento da mensagem.
  80. 80. Comunicação não bloqueante if (rank==0) { ............ MPI_Isend(&a[0][0]+(k*n*i),k*n,MPI_DOUBLE,i,10,MPI_COMM_WO RLD,&req); printf("rank 0 apos Sendn"); fflush(stdout); ....... } else { MPI_Recv(a,k*n,MPI_DOUBLE,0,10,MPI_COMM_WORLD,&status); ........... }
  81. 81. Comunicação coletiva MPI_Bcast(void *buf,int count,MPI_Datatype dtype,int root,MPI_Comm comm); • todos processos executam a mesma chamada de função. • Após a execução da chamada todos os buffers contêm os dados do buffer do processo root.
  82. 82. Comunicação coletiva MPI_Scatter(void *sendbuf,int sendcount, MPI_Datatype sendtype,void *recvbuf, int recvcount,MPI_Datatype recvtype,int root, MPI_Comm comm); • todos os N processos do comunicador especificam o mesmo count (número de elementos a serem recebidos). • O buffer de root: contém sendcount*N elementos do datatype tipo especificado. • processo root: distribuirá os dados para os processos, incluindo ele próprio.
  83. 83. Comunicação coletiva MPI_Gather(void *sendbuf,int sendcount,MPI_Datatype sendtype,void *recvbuf,int recvcount,MPI_Datatype recvtype,int root,MPI_Comm comm); • operação gather: reverso da operação scatter ( dados de buffers de todos processos para processo root)
  84. 84. Exemplo: MPI_Scatter if (rank==0) { for(i=0;i<n;i++) for(j=0;j<n;j++) a[i][j]=1; } MPI_Scatter(a,k*n,MPI_DOUBLE,a,k*n,MPI_DOUBLE,0 ,MPI_COMM_WORLD); // rank 0: root parcial=0; for(i=0;(i<k);i++) for(j=0;j<n;j++) parcial+=a[i][j];
  85. 85. Comunicação coletiva • MPI_Reduce(void *sendbuf,void *recvbuf,int count,MPI_Datatype dtype,MPI_Op op,int root,MPI_Comm comm); • Elementos dos buffers de envio: combinados par a par para um único elemento correspondente no buffer de recepção do root. • Operaçoes de redução: • MPI_MAX (maximum), MPI_MIN (minimum), MPI_SUM (sum), MPI_PROD (product), MPI_LAND (logical and), MPI_BAND (bitwise and) MPI_LOR (logical or) MPI_BOR (bitwise or) MPI_LXOR (logical exclusive or) MPI_BXOR (bitwise exclusive or)
  86. 86. Exemplo: MPI_Reduce k=n/n_nos; MPI_Scatter(a,k*n,MPI_DOUBLE,a,k*n,MPI_DOUBLE,0,M PI_COMM_WORLD); // rank 0: root parcial=0; fim=k; for (i=0;i<fim;i++) for (j=0;j<n;j++) parcial=parcial+a[i][j]; MPI_Reduce(&parcial,&soma,1,MPI_DOUBLE,MPI_SUM ,0,MPI_COMM_WORLD); // rank 0: root
  87. 87. Aplicação Projeto OpenModeller Objetivo: construir uma versão eficiente da ferramenta OpenModeller para predizer a distribuição de espécies em uma área geográfica a partir de informações de presença em um conjunto de locais e as condições topográficas e climáticas. Instituções: CRIA, EPUSP, INPE Participação do LAHPC: paralelização da aplicação
  88. 88. Biodiversidade • Mapa de distribuição da espécie
  89. 89. OpenModeller Duas etapas: • Modelagem: modelagem da presença da espécie considerando condições climáticas e geográficas (layers) - dados de presença coletados em campo • Projeção: prediz a presença da espécie em pontos de uma área
  90. 90. Biodiversidade • Experimento: – Predição da distribuição de uma espécie para um conjunto de camadas ambientais cortados para a região sudeste com alta resolução (250m). – Paralelização do passo de projeção. • Plataforma de execução:cluster Programação utilizando MPI
  91. 91. experimento
  92. 92. Estratégia de paralelização Nó 1 result.. Solicita Nó 0 bloco Info bloco CPU Nó 2 Nó 5 Nó 3 Buffer de Nó 4 mensagens
  93. 93. Biodiversidade •Tempo de execução sequencial: 66 min. •Tempo de execução da projeção na aplicação openModeller versão paralelizada: Desempenho da execução do experimento de predição de distribuição de espécie usando M PI 80 70 60 50 Tempo em Minuto s 40 30 20 10 0 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 Número de pro ces s ado res
  94. 94. Conclusão Impacto da computação de alto desempenho nas áreas da computação • Novas ferramentas de programação • Metodologias e Ferramentas de desenvolvimento • Novos algoritmos Desafios • Facilitar a programação • Facilitar o uso das plataformas (multi-core, clusters, grids) • Disseminar como utilizar e explorar o uso dos recursos destas plataformas
  95. 95. Conclusão Pesquisas • construção de grids para processamento paralelo – MPI utilizando múltiplos clusters e servidores • ambientes de programação paralela – ideal: mesma linguagens atendendo estas plataformas • clusters heterogêneos • uso de outras arquiteturas ( GPUs) • paralelização de aplicações
  96. 96. Bibliografia 1. Ben-Ari, M. "Principles of Concurrent and Distributed Programming", Addison-Wesley, Second Edition, 2006. 2. Akthter, S.; Roberts, J. " Multi-Core Programming"; Intel Press, 2006. 3. Grama, A.; Gupta,A.; Karypis, G.; Kumar, V. "Introduction to Parallel Computing"; Addison-Wesley, Second Edition, 2003. 4. Culler, D.E.;Singh, J.P.;Gupta, A. "Parallel Computer Architecture: a hardware/software approach"; Morgan Kaufmann Publishers, Inc. , 1999. 5. Quinn, M.J. “Parallel Programming in C with MPI and OpenMP”; McGraw-Hill – Higher Education, 2004.
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×