A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

1 Introdução à Computação Paralela e Ambientes de Grade Departamento de Ciência de Computadores Universidade do Porto Inês de Castro.

Apresentações semelhantes


Apresentação em tema: "1 Introdução à Computação Paralela e Ambientes de Grade Departamento de Ciência de Computadores Universidade do Porto Inês de Castro."— Transcrição da apresentação:

1 1 Introdução à Computação Paralela e Ambientes de Grade Departamento de Ciência de Computadores Universidade do Porto Inês de Castro Dutra

2 2 Grades Computacionais Idéia é utilizar computadores independentes geograficamente distantes Diferenças: clusters x grids heterogeneidade (nós muito diferentes) alta dispersão geográfica (escala mundial) compartilhamento (inexistente) múltiplos domínios administrativos controle totalmente distribuído

3 3 Grades Computacionais Componentes PCs, SMPs, MPPs, clusters controlados por diferentes entidades diversos domínios administrativos Não têm uma imagem única do sistema Sistema não dedicado Aplicação deve estar preparada para: dinamismo variedade de plataformas

4 4 Grades Computacionais Escalonamento de aplicação recursos controlados por vários escalonadores distintos que devem decidir: quais recursos serão utilizados pela aplicação quais tarefas cada um destes recursos realizará submeter solicitações aos escalonadores apropriados tarefa do escalonador de aplicações Grids: duas camadas de escalonamento

5 5 Grades Computacionais Escalonador de Aplicação Escalonador de Aplicação Escalonador de Recursos Escalonador de Recursos Escalonador de Recursos usuário MPP SMP Cluster

6 6 Grades Computacionais Internet MPP SMP Cluster Servidor Computador convencional Workstation Servidor Workstation

7 7 Grades Computacionais Middleware: Globus, Condor, OurGrid, gLite usuário pode obter poder computacional de forma transparente sob demanda Soluções: evitam problemas no nível do usuário introduzem novas abstrações que facilitam o uso da grade

8 8 Top500 Supercomputer SiteComputerProcsYearR max R peak DOE/NNSA/LLNL DOE/NNSA/LLNL United States BlueGene/L - eServer Blue Gene Solution BlueGene/L - eServer Blue Gene Solution IBM IBM Thomas J. Watson Research Center IBM Thomas J. Watson Research Center United States BGW - eServer Blue Gene Solution BGW - eServer Blue Gene Solution IBM DOE/NNSA/LLNL DOE/NNSA/LLNL United States ASC Purple - eServer pSeries p GHz ASC Purple - eServer pSeries p GHz IBM NASA/Ames Research Center/NAS NASA/Ames Research Center/NAS United States Columbia - SGI Altix 1.5 GHz, Voltaire Infiniband Columbia - SGI Altix 1.5 GHz, Voltaire Infiniband SGI Sandia National Laboratories Sandia National Laboratories United States Thunderbird - PowerEdge 1850, 3.6 GHz, Infiniband Thunderbird - PowerEdge 1850, 3.6 GHz, Infiniband Dell Sandia National Laboratories Sandia National Laboratories United States Red Storm Cray XT3, 2.0 GHz Red Storm Cray XT3, 2.0 GHz Cray Inc The Earth Simulator Center The Earth Simulator Center Japan Earth-Simulator Earth-Simulator NEC Barcelona Supercomputer Center Barcelona Supercomputer Center Spain MareNostrum - JS20 Cluster, PPC 970, 2.2 GHz, Myrinet MareNostrum - JS20 Cluster, PPC 970, 2.2 GHz, Myrinet IBM ASTRON/University Groningen ASTRON/University Groningen Netherlands Stella - eServer Blue Gene Solution Stella - eServer Blue Gene Solution IBM Oak Ridge National Laboratory Oak Ridge National Laboratory United States Jaguar - Cray XT3, 2.4 GHz Jaguar - Cray XT3, 2.4 GHz Cray Inc Rmax Maximal LINPACK performance achieved Rpeak Theoretical peak performance GFlopss

9 9 Resumindo... Plataformas de Execução Paralela

10 10 Programação Paralela

11 11 Programação Paralela Paralelismo explícito Linguagens (SR) Bibliotecas (OpenMP, MPI) Suporte de Sistema (lib do SO) Paralelismo implícito Compiladores paralelizadores (F90, HPF) Linguagens declarativas (Prolog) Sistemas híbridos (Concurrent Logic)

12 12 Modelos de Programação Paralela Modelos Memória Compartilhada Passagem de Mensagem Paradigmas SPMD (Single Program Multiple Data) MPDM (Multiple Program Multiple Data)

13 13 Ambientes de Programação Paralela Clusters Memória Compartilhada Software DSM (Click, HLRC, TreadMarks) Passagem de Mensagens PVM MPI OpenMP

14 14 Ambiente: PVM Modelo de programação passagem de mensagem software: biblioteca no nível do usuário (C/Fortran) protocolo TCP ou UDP Modelos de paralelismo: SPMD ou MPDM

15 15 Primitivas para: criação e gerenciamento de processos troca explícita de mensagens primitivas de PVM possuem o prefixo PVM_ Sistemas computacionais: homogêneos ou heterogêneos Ambiente: PVM

16 16 Ambiente: MPI Padronização a partir do PVM Modelo de programação: passagem de mensagem software: biblioteca no nível do usuário (C/Fortran) protocolo TCP ou UDP Modelos de paralelismo: SPMD ou MPDM

17 17 Ambiente: MPI Primitivas para: criação e gerenciamento de processos troca explícita de mensagens primitivas de MPI possuem o prefixo MPI_ Sistemas computacionais: homogêneos ou heterogêneos Corrige algumas deficiências técnicas do PVM

18 18 Ambiente: OpenMP Busca por uma padronização de facto Organização independente envolvendo fabricantes de computadores (SGI, Compaq, Hewllet-Packard, Intel, IBM, Kuck & Associates, Sun, U.S. Department of Energy ASCI Program) desenvolvedores de aplicações e vendedores

19 19 Ambiente: OpenMP Modelo de programação: semelhante ao modelo seqüencial desenvolvido para dar suporte ao passo final da implementação de um algoritmo paralelo linguagens: C, C++ e Fortran expressão do paralelismo diretivas incluídas no código fonte (comentários em Fortran e #pragmas em C ou C ++) em conjunto com rotinas de bibliotecas

20 20 Programação Paralela Grades Computacionais Globus Toolkit Condor OurGrid gLite

21 21 Globus Toolkit Data Mgmt Security Common Runtime Execution Mgmt Info Services GridFTP Authentication Authorization Reliable File Transfer Data Access & Integration Grid Resource Allocation & Management Index Community Authorization Data Replication Community Scheduling Framework Delegation Replica Location Trigger Java Runtime C Runtime Python Runtime WebMDS Workspace Management Grid Telecontrol Protocol Globus Toolkit v4 Credential Mgmt

22 22 Sistema Condor Adaptable Customizable Resource Access Control Match-Making Request Agent Application RM Application Condor Resource Owner System Administrator Customer/User Distributed Scalable Sistema Condor

23 23 Sistema Condor Central Manager (Friedas) master collector negotiator schedd startd = ClassAd Communication Pathway = Process Spawned Desktop schedd startd master Desktop schedd startd master Cluster Node master startd Cluster Node master startd Sistema Condor

24 24 Sistema Condor-G Globus middleware deployed across entire Grid remote access to computational resources dependable, robust data transfer Condor job scheduling across multiple resources strong fault tolerance with checkpointing and migration layered over Globus as personal batch system for the Grid

25 25 Sistema Condor-G

26 26 Sistema OurGrid Aplicações Bag-of-Tasks (BoT) Compartilhamento de recursos peer-to-peer Principais componentes OurGrid peer: Network of Favors mecanismo de alocação autônomo e totalmente descentralizado MyGrid broker: escalonamento SWAN security service: máquina virtual de proteção

27 27 Sistema OurGrid Ourgrid

28 28 gLite Utiliza funções do Globus Estrutura: BDII, UI, RB, WN, CE, SE, IE Aplicações definidas utilizando JDL Middleware adotado pelo projeto de grid europeu (EGEE) Outros componentes: AMGA LFC API semelhante a de outros RMSs

29 29 Desenvolvimento de Programas Paralelos

30 30 Metodologia para Programação Paralela Metodologia é (quase) independente da máquina Estágios: particionamento comunicação aglomeração mapeamento

31 31 Particionamento Divisão da aplicação em tarefas em menores Decomposição do domínio da aplicação Objetivos aumentar: concorrência localidade de referência

32 32 Comunicação Troca de informações entre processos Sincronização entre processos Definir: estruturas de dados e algoritmos apropriados

33 33 Aglomeração Avaliação de requisitos de desempenho e custo Objetivos se necessário: combinar tarefas para reduzir custos de comunicação tarefas maiores podem melhorar o desempenho, mesmo que diminua a concorrência

34 34 Mapeamento Cada tarefa é atribuída a um processador Estático ou dinâmico Objetivos: maximizar a utilização dos processadores minimizar os custos de comunicação balanceamento de carga

35 35 Metodologia para Programação Paralela Problema Particionamento Comunicação Aglomeração Mapeamento

36 36 Métricas de Desempenho

37 37 Métricas de Desempenho Speedup = grau de melhora de desempenho Eficiência = porção utilizada da capacidade Redundância = aumento da carga qdo em p processadores Utilização = utilização dos recursos durante computação Qualidade = importância de utilizar processamento paralelo

38 38 Métricas de Desempenho Speedup s(p) = T(1) / T(p), onde T(1) = tempo do melhor algoritmo sequencial possível e p = número de processadores Eficiência e(p) = s / p = T(1) / (p T(p)) Redundância r(p) = O(p) / O(1), onde O(p) = número total de ops em máquina com p processadores Utilização u(p) = r(p) e(p) = O(p) / (p T(p)) Qualidade q(p) = (s(p) e(p)) / r(n) = T3(1) / (p T2(p) O(p))

39 39 Escalabilidade Modelos de aplicações Limites algorítmicos Limites arquiteturais Métricas de Desempenho

40 40 Carga fixa = máquinas maiores para computar + rápido Tempo fixo = máquinas maiores para problemas maiores Memória fixa = máquinas maiores para problemas que precisam de + memória Modelos de Aplicações

41 41 Falta de paralelismo Freqüência de sincronização Padrão de comunicação/acesso Escalonamento deficiente Limites Algorítmicos

42 42 Latência/banda de comunicação Latência/banda de E/S Overhead de sincronização Overhead de coerência Capacidade de memória Limites Arquiteturais

43 43 Métricas de Desempenho Lei de Amdahl: Speedup: s = T(1)/T(p) Trabalho total: c = Ts + Tp = T(1) T(p) = Ts + Tp/p s = (Ts + Tp) / (Ts + Tp/p) = c / (Ts + Tp/p) s = c/Ts qdo p tende a infinito

44 44 Métricas de Desempenho Lei de Gustafson: Tempo total: c = Ts + Tp Trabalho total: t = Ts + Tp Scaled Speedup ss = t / c ss = (Ts + p * Tp) / (Ts + Tp) = (Ts + p * Tp) / c = (Ts + p * (c - Ts)) / c = p + (Ts * (1-p)) / c, linear em Ts

45 45 Métricas de Desempenho Speedup superlinear: Overhead reduzido (escalonamento, por exemplo) Mais memória/cache Tolerância a latência Randomização (problemas de otimização) Problemas que possuem múltiplas soluções

46 46 Exemplos

47 47 Modelo de Programação Seqüencial Modelo mais simples Paralelismo implementado pelo compilador ou software + básico for i = 1 to N a[i] = 1 Paralelismo explorado pelo compilador (p.e.: F90, HPF ou runtime paralelo)

48 48 Modelo de Programação Paralelo baseado em Memória Compartilhada doall i = 1 to N a[i] = 1 for j = 1 to NPROCS-1 fork(compute,j) compute(0) lock(mutex) x = x + 1 unlock(mutex)

49 49 Modelo de Programação Paralelo baseado em Troca de Mensagens Proc pid: (N é o tamanho do problema) chunk = N/NPROCS for j = pid*chunk to (pid+1)*chunk-1 a[i] = 1 send(dest,&a[pid*chunk],chunk*sizeof(int))

50 50 Programando em MC

51 51 Exemplo usando Posix threads (thread do_work) #include #define NTHREADS 4 #define ARRAYSIZE #define ITERATIONS ARRAYSIZE / NTHREADS double sum=0.0, a[ARRAYSIZE]; pthread_mutex_t sum_mutex; void *do_work(void *tid) { int i, start, *mytid, end; double mysum=0.0; /* Initialize my part of the global array and keep local sum */ mytid = (int *) tid; start = (*mytid * ITERATIONS); end = start + ITERATIONS; printf ("Thread %d doing iterations %d to %d\n",*mytid,start,end-1); for (i=start; i < end ; i++) mysum = mysum + a[i]; /* Lock the mutex and update the global sum, then exit */ pthread_mutex_lock (&sum_mutex); sum = sum + mysum; pthread_mutex_unlock (&sum_mutex); pthread_exit(NULL); }

52 52 Exemplo usando Posix threads (main thread) int main(int argc, char *argv[]) { int i, start, tids[NTHREADS]; pthread_t threads[NTHREADS]; /* Pthreads setup: initialize mutex. Pass each thread its loop offset */ pthread_mutex_init(&sum_mutex, NULL); for (i=0; i

53 53 Exemplo usando Processos (cliente/servidor) #include #define SHMSZ 27 main() { char c, *shm, *s; int chave = 5678, shmid; shmid = shmget(chave, SHMSZ, (IPC_CREAT|0666)); shm = (char *) shmat(shmid, NULL, 0); s= shm; /* escreve info em memória */ for (c=a; c < =z; c++) *s++= c; *s = \0; /* espera até que outro proc altere o 1o. char em memória */ while (*shm != *) sleep(1); shmdt(shmid); /* liberta segmento */ exit(0); }

54 54 Exemplo usando Processos (cliente/servidor) #include #define SHMSZ 27 main() { char c, *shm, *s; int chave= 5678, shmid; shmid= shmget(chave, SHMSZ, 0666); shm= (char *) shmat(shmid, NULL, 0); for (s=shm; *s!=\0; s++) /* lê da memória compartilhada*/ putchar(*s); putchar(\n); *shm=*; /* alterar o 1o. caracter em memória */ exit(0); }

55 55 Exemplo usando OpenMP PROGRAM HELLO PRINT *, Hello parallel world from threads: !$OMP PARALLEL PRINT *, OMP_GET_THREAD_NUM ( ) !$OMP END PARALLEL PRINT *, Back to the sequential world. STOP END

56 56 Exemplo usando OpenMP: saída Saída do programa HELLO Hello parallel world from threads: Back to the sequential world.

57 57 Programando com Troca de Msgs usando MPI

58 58 Exemplo: usando MPI #include #include "mpi.h" main(int argc, char* argv[]) { int my_rank; /* rank of process */ int p; /* number of processes */ int source; /* rank of sender */ int dest; /* rank of receiver */ int tag = 0; /* tag for messages */ char message[100]; /* storage for message */ MPI_Status status; /* return status for receive */ /* Start up MPI */ MPI_Init(&argc, &argv); /* Find out process rank */ MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); /* Find out number of processes */ MPI_Comm_size(MPI_COMM_WORLD, &p); if (my_rank != 0) { /* Create message */ sprintf(message, "Greetings from process %d!", my_rank); dest = 0; /* Use strlen+1 so that '\0' gets transmitted */ MPI_Send(message, strlen(message)+1, MPI_CHAR, dest, tag, MPI_COMM_WORLD); } else { /* my_rank == 0 */ for (source = 1; source < p; source++) { MPI_Recv(message, 100, MPI_CHAR, source, tag, MPI_COMM_WORLD, &status); printf("%s\n", message); } /* Shut down MPI */ MPI_Finalize(); } /* main */

59 59 Computação sobre uma matriz Grupo de linhas consecutivas para cada processador Cada elemento calculado usando vizinhos Comunicação nas bordas Exemplo: SOR (Successive Over-Relaxation)

60 60 Usando modelo de memória compartilhada: for num_iters for num_minhas_linhas compute barreira Usando modelo de troca de mensagens define submatriz local for num_iters if pid != 0 envia primeira linha a pid-1 recebe limite superior de pid-1 if pid != P-1 envia ultima linha a pid+1 recebe limite inferior de pid+1 for num_linhas compute Exemplo: SOR (Successive Over-Relaxation) P0 P1 P2

61 61 Universe = standard Executable = /u/dutra/Yap /condor/yap.$$(Arch).$$(OpSys) Initialdir = /u/dutra/new_experiments/Carcino/diffseeds/theories/x5x4/f5/123 Log = /u/dutra/new_experiments/Carcino/diffseeds/theories/x5x4/f5/123/log Requirements = ((Arch == "INTEL" && OpSys == "LINUX") && (Mips >= 500) && Memory >= 400) || (Arch == "SUN4u" && OpSys == "SOLARIS28") || (IsDedicated && UidDomain == "cs.wisc.edu")) Arguments = -b /u/dutra/Yap /condor/../pl/boot.yap Input = condor.in.$(Process) Output = /dev/null Error = /dev/null Queue 300 Exemplo: Usando Condor (subm file)

62 62 ['/u/dutra/Yap /condor/../pl/init.yap']. module(user). ['/u/dutra/new_experiments/Aleph/aleph.pl']. read_all('/u/dutra/new_experiments/Carcino/PL/x5x4/f5/123/train'). set(i,5). set(minacc,0.7). set(clauselength,4). set(recordfile,'/u/dutra/new_experiments/Carcino/ diffseeds/theories/x5x4/f5/123/trace '). set(test_pos,'/u/dutra/new_experiments/Carcino/PL/x5x4/f5/123/test.f'). set(test_neg,'/u/dutra/new_experiments/Carcino/PL/x5x4/f5/123/test.n'). set(evalfn,coverage). induce. write_rules('/u/dutra/new_experiments/Carcino/ diffseeds/theories/x5x4/f5/123/theory '). halt. Exemplo: Usando Condor (input file)

63 63 Executable = "/home/SO/marluce/tmp/yap/condor/yap"; InputSandbox = { "/home/SO/marluce/tmp/yap/condor/yap", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/*.pl", "home/SO/marluce/tmp/CondorBench//Aleph/aleph.pl", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.b", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.f", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.n", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/condor.in.0" }; OutputSandbox = { "theory ", "trace "}; InputData = { "/home/SO/marluce/tmp/yap/condor/yap", "home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/*.pl", home/SO/marluce/tmp/CondorBench//Aleph/aleph.pl, home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.b, home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.f, home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/train.n, home/SO/marluce/tmp/CondorBench//Carcino/diffseeds/theories/x5x4/f1/2/condor.in.0 }; Arguments = "/home/SO/marluce/tmp/yap/condor/yap < home/SO/marluce/tmp/CondorBench/ Carcino/diffseeds/theories/x5x4/f1/2/condor.in.0"; Requirements = "((Arch == "INTEL" && OpSys == "LINUX") && (Mips >= 500) && Memory >= 400)"; StdInput = "condor.in.0"; StdOutput = "/dev/null"; StdError = "/dev/null"; Exemplo: Usando JDL

64 64 DSM TOP500 Supercomputers Globus Toolkit gLite Condor OurGrid PVM MPI OurGrid Projeto EGEE: Projeto EELA: Global Grid Forum: Referências

65 65 Obrigada!!


Carregar ppt "1 Introdução à Computação Paralela e Ambientes de Grade Departamento de Ciência de Computadores Universidade do Porto Inês de Castro."

Apresentações semelhantes


Anúncios Google