Post on 17-Apr-2015
1
Introdução à Computação Paralela e Ambientes de
Grade
Departamento de Ciência de Computadores
Universidade do Porto
ines@dcc.fc.up.pt
Inês de Castro Dutra
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
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
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
Grades Computacionais
Escalonador
de AplicaçãoEscalonador
de Aplicação
Escalonador
de Recursos
Escalonador
de Recursos
Escalonador
de Recursos
usuário usuário usuário
MPP SMP
SMP
Cluster
6
Grades Computacionais
Internet
MPP
MPPSMP
SMP
Cluster
Cluster
Servidor
Computador convencional
Workstation
Servidor
Workstation
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
Top500 Supercomputer
Site Computer Procs Year Rmax Rpeak
DOE/NNSA/LLNLUnited States
BlueGene/L - eServer Blue Gene SolutionIBM
131072 2005280600
367000
IBM Thomas J. Watson Research CenterUnited States
BGW - eServer Blue Gene SolutionIBM
40960 2005 91290114688
DOE/NNSA/LLNLUnited States
ASC Purple - eServer pSeries p5 575 1.9 GHzIBM
10240 2005 63390 77824
NASA/Ames Research Center/NASUnited States
Columbia - SGI Altix 1.5 GHz, Voltaire InfinibandSGI
10160 2004 51870 60960
Sandia National LaboratoriesUnited States
Thunderbird - PowerEdge 1850, 3.6 GHz, InfinibandDell
8000 2005 38270 64512
Sandia National LaboratoriesUnited States
Red Storm Cray XT3, 2.0 GHzCray Inc.
10880 2005 36190 43520
The Earth Simulator CenterJapan
Earth-SimulatorNEC
5120 2002 35860 40960
Barcelona Supercomputer CenterSpain
MareNostrum - JS20 Cluster, PPC 970, 2.2 GHz, MyrinetIBM
4800 2005 27910 42144
ASTRON/University GroningenNetherlands
Stella - eServer Blue Gene SolutionIBM
12288 2005 2745034406.4
Oak Ridge National LaboratoryUnited States
Jaguar - Cray XT3, 2.4 GHzCray Inc.
5200 2005 20527 24960
Rmax Maximal LINPACK performance achieved Rpeak Theoretical peak performance GFlopss
9
Resumindo...
Características SMPs MPPs NOWs GridsConectividade excelente muito boa boa média/ruimHeterogeneidade nula baixa média altaCompartilhamento não não sim simImagem do Sistema única comum comum múltiplaEscalabilidade 10 1.000 1.000 100.000
Plataformas de Execução Paralela
10
Programação Paralela
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
Modelos de Programação Paralela
Modelos
Memória Compartilhada
Passagem de Mensagem
Paradigmas
SPMD (Single Program Multiple Data)
MPDM (Multiple Program Multiple Data)
13
Ambientes de Programação Paralela
Clusters Memória Compartilhada
Software DSM (Click, HLRC, TreadMarks)
Passagem de Mensagens PVM MPI
OpenMP
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
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
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
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
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
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
Programação Paralela
Grades Computacionais Globus Toolkit
Condor OurGrid gLite
21
Globus Toolkit
Data Mgmt
SecurityCommonRuntime
Execution Mgmt
Info Services
GridFTPAuthenticationAuthorization
ReliableFile
Transfer
Data Access& Integration
Grid ResourceAllocation &
ManagementIndex
CommunityAuthorization
DataReplication
CommunitySchedulingFramework
Delegation
ReplicaLocation
Trigger
Java Runtime
C Runtime
Python Runtime
WebMDS
WorkspaceManagement
Grid Telecontrol
Protocol
Globus Toolkit v4www.globus.org
CredentialMgmt
22
Sistema Condor
Adaptable
Customizable
ResourceResource
Access ControlAccess Control
Match-MakingMatch-Making
Request AgentRequest Agent
Application RMApplication RM
ApplicationApplication
Con
dor
Resource OwnerResource Owner
SystemSystem AdministratorAdministrator
Customer/UserCustomer/User
Distributed
Scalable
Sistema Condor www.wisc.edu/condor
23
Sistema Condor
Central Manager (Frieda’s)
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
startdSistema Condor
www.wisc.edu/condor
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
www.wisc.edu/condor
25
Sistema Condor-G
www.wisc.edu/condor
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
www.ourgrid.org
27
Sistema OurGrid
www.ourgrid.org
Ourgrid
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
www.ourgrid.org
29
Desenvolvimento de Programas Paralelos
30
Metodologia para Programação Paralela
Metodologia é (quase) independente da máquina
Estágios:
particionamento
comunicação
aglomeração
mapeamento
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
Comunicação
Troca de informações entre processos
Sincronização entre processos
Definir:
estruturas de dados e
algoritmos apropriados
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
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
Metodologia para Programação Paralela
ProblemaParticionamento
Comunicação
Aglomeração
Mapeamento
36
Métricas de Desempenho
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
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
• Escalabilidade• Modelos de aplicações• Limites algorítmicos• Limites arquiteturais
Métricas de Desempenho
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
• Falta de paralelismo
• Freqüência de sincronização
• Padrão de comunicação/acesso
• Escalonamento deficiente
Limites Algorítmicos
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
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
Métricas de Desempenho
Lei de Gustafson:
Tempo total: c = Ts + Tp
Trabalho total: t = Ts + Tp
Scaled Speedup ss = t / css = (Ts + p * Tp) / (Ts + Tp)
= (Ts + p * Tp) / c = (Ts + p * (c - Ts)) / c = p + (Ts * (1-p)) / c, linear em Ts
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
Exemplos
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
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 + 1unlock(mutex)
49
Modelo de Programação Paralelo baseado em Troca de Mensagens
Proc pid: (N é o tamanho do problema)
chunk = N/NPROCSfor j = pid*chunk to (pid+1)*chunk-1 a[i] = 1send(dest,&a[pid*chunk],chunk*sizeof(int))
50
Programando em MC
51
Exemplo usando Posix threads (thread do_work)#include <pthread.h> #include <stdio.h> #include <stdlib.h> #define NTHREADS 4 #define ARRAYSIZE 1000000 #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
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<NTHREADS; i++) { tids[i] = i; pthread_create(&threads[i], NULL, do_work, (void *) &tids[i]); } /* Wait for all threads to complete then print global sum */ for (i=0; i<NTHREADS; i++) { pthread_join(threads[i], NULL); } printf ("Done. Sum= %e \n", sum); sum=0.0; for (i=0;i<ARRAYSIZE;i++) sum = sum + a[i]; printf("Check Sum= %e\n",sum); /* Clean up and exit */ pthread_mutex_destroy(&sum_mutex); pthread_exit (NULL); }
53
Exemplo usando Processos (cliente/servidor)#include <sys/ipc.h>#include <sys/shm.h>#define SHMSZ 27main() { 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
Exemplo usando Processos (cliente/servidor)
#include <sys/ipc.h>#include <sys/shm.h>#define SHMSZ 27main(){ 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
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
Exemplo usando OpenMP: saída
Saída do programa HELLO
Hello parallel world from threads:
1
3
0
2 Back to the sequential world.
57
Programando com Troca de Msgs usando MPI
58
Exemplo: usando MPI#include <stdio.h>#include <string.h>#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
• 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
•Usando modelo de memória compartilhada:for num_iters for num_minhas_linhas compute barreira
• Usando modelo de troca de mensagensdefine submatriz localfor 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
Universe = standardExecutable = /u/dutra/Yap-4.3.20/condor/yap.$$(Arch).$$(OpSys)Initialdir = /u/dutra/new_experiments/Carcino/diffseeds/theories/x5x4/f5/123Log = /u/dutra/new_experiments/Carcino/diffseeds/theories/x5x4/f5/123/logRequirements = ((Arch == "INTEL" && OpSys == "LINUX") && (Mips >= 500) && Memory >= 400) || (Arch == "SUN4u" && OpSys == "SOLARIS28") || (IsDedicated && UidDomain == "cs.wisc.edu"))
Arguments = -b /u/dutra/Yap-4.3.20/condor/../pl/boot.yapInput = condor.in.$(Process)Output = /dev/nullError = /dev/null
Queue 300
Exemplo: Usando Condor (subm file)
62
['/u/dutra/Yap-4.3.20/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-0.7-4.0').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-0.7-4.0').halt.
Exemplo: Usando Condor (input file)
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-0.9-5.0", "trace-0.9-5.0"};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
DSM http://www.ics.uci.edu/~javid/dsm.html
TOP500 Supercomputers http://www.top500.org
Globus Toolkit http://www.globus.org/toolkit/
gLite http://glite.web.cern.ch/glite/
Condor http://www.wisc.edu/condor
OurGrid http://www.ourgrid.org
PVM http://www.csm.ornl.gov/pvm
MPI http://www.mpi-forum.org
OurGrid http://www.ourgrid.org
Projeto EGEE: http://www.egee.org
Projeto EELA: http://www.eu-eela.org
Global Grid Forum: http://www.ggf.org
Referências
65
Obrigada!!