Escolar Documentos
Profissional Documentos
Cultura Documentos
Em convênio com:
IC – Instituto de Computação
UFF – Universidade Federal Fluminense
Introdução e Conceitos Básicos
dificuldades encontradas
– mas como?
– paralelizar uma solução?
Aerospace
Life Sciences Internet & Ecommerce
• Paralelismo
uma aplicação é executada por um conjunto de processadores em um ambiente
único (dedicados)
• Computação distribuída
aplicações sendo executadas em plataformas distribuídas
Definindo melhor alguns conceitos
Aplicação Paralela
– várias tarefas
– vários processadores
• redução no tempo total de execução
Modelos de Programação Paralela
Comunicação
– memória compartilhada
• visão de um único espaço de endereçamento global
– memória distribuída
• troca explícita de mensagens
Modelos de Programação Paralela
Metas
– aumento no desempenho
– maior eficiência
Objetivos
Visão geral
– arquitetura de computadores
– ambientes de programação paralela
– modelos de programação paralela
Classificação de Computadores
– Computadores Convencionais
– Memória Centralizada
– Memória Distribuída
Arquitetura de Computadores
Sistema Paralelo
– vários processadores
– espaço de endereçamento
– mecanismo de comunicação
Grades Computacionais
SMPs
SMPs ou Multiprocessadores
Sistema homogêneo
Compartilhamento
– Compartilhamento total da mesma memória
Uma única cópia do Sistema Operacional
Imagem única do sistema
Excelente conectividade
– fortemente acoplados
Não escalável
Exemplos:
– Sun HPC 10000 (StarFire), SGI Altix, SGI Origin, IBM pSeries, Compac
AlphaServer
SMPs
Multiprocessadores
CPU
Memória CPU
...
CPU
MPPs (Multicomputadores)
Um escalonador de tarefas
– partições diferentes para aplicações diferentes
MPPs
Exemplos:
– Cray T3E, IBM SP2s, clusters montados pelo próprio usuário, com
propósito de ser um MPP
MPPs
Multicomputadores
Escalonador
Utilização de computadores
– independentes
– geograficamente distantes
– heterogeneidade de recursos
– alta dispersão geográfica (escala mundial)
– compartilhamento
– múltiplos domínios administrativos
– controle totalmente distribuído
Grades Computacionais
Componentes
– PCs, SMPs, MPPs, clusters
– controlados por diferentes entidades ⇒ diversos domínios administrativos
Escalonador Escalonador
de Aplicação de Aplicação
Computador
convencional
Workstation MPP
Cluster
Workstation
Internet
SMP
SMP MPP
Servidor
Resumo
Plataformas de Execução Paralela
NNSA/Sandia National Laboratories Red Storm - Sandia/ Cray Red Storm, Opteron 2.4 GHz
2 United States
dual 26544 2006 101400 127411
Cray Inc.
3 IBM Thomas J. Watson Research Center BGW - eServer Blue Gene Solution
40960 2005 91290 114688
United States IBM
4 DOE/NNSA/LLNL
United States
ASC Purple - eServer pSeries p5 575 1.9 GHz
IBM
12208 2006 75760 92781
7 Commissariat a l'Energie Atomique (CEA) Tera-10 - NovaScale 5160, Itanium2 1.6 GHz, Quadrics
9968 2006 52840 63795.2
France Bull SA
NASA/Ames Research Center/NAS Columbia - SGI Altix 1.5 GHz, Voltaire Infiniband
8 United States SGI
10160 2004 51870 60960
363 University of San Paulo BladeCenter JS21 Cluster, PPC970, 2.5 GHz, Myrinet
448 2006 3182.38 4480
Brazil IBM
Grid Computing
• Heterogêneos
• Compartilhados
• Aspectos que devem ser tratados
• Segurança
• Falhas de recursos
• Gerenciamento da execução de várias aplicações
Computação em Grid
tempo t
7+3 string
10 +==“casa”?
200 32 +
33 * 329
14
Paralelismo de Controle
Exemplo:
– Pipelining: cada estágio trabalha em velocidade plena sobre uma parte particular
da computação. A saída de um estágio é a entrada do estágio seguinte
Paralelismo de Controle
E1 E2 E3 E4
tempo
info 1
info 2 info 1
OU
Particionamento
– identificar em um programa, as tarefas que possam ser executadas em
paralelo (simultaneamente em mais de um processador)
Tarefa T1 Tarefa T2
input (A,B,C); A = 0;
if A>B then{
C=A-B; Tarefa T3
output (C); B=1;
}else{
C = B-A; Tarefa T4
output (A,B,C) for i=1 to 3 {
} input(C);
A=A+C;
B=B*C;
}
output (A,B,C)
Exemplo
T2 1 T3 1
T1
4
T4
16
Exemplo: Soma n números
P r o b l e m a : s o m a r nn ú m e r o s q u a i s q u e r
Programa sequencial:
⇓
Paralelizar e gerenciar algoritmos paralelos não é uma tarefa fácil
Programação Paralela
Dificuldades encontradas
Processos/tarefas
Independência da arquitetura
Fácil entendimento
Aspectos Explorados pelo Modelo
Facilidade de programação
nível de abstração
nível de máquina
Aspectos Explorados pelo Modelo
O modelo deve ser capaz de oferecer facilidades tais que seja fácil:
Decompor o programa em tarefas paralelas
Mapear as tarefas nos processadores físicos
– custo de comunicação
– heterogeneidade dos processadores
Sincronização entre tarefas: é preciso ter conhecimento do estado global da
estrutura de execução do programa (quando é necessário sincronizar?)
Abstraindo para Programar
Dimensão Temporal
propriedades chaves:
– execução síncrona sem nenhum custo adicional para a
sincronização
– comunicação realizada em uma unidade de tempo, qualquer que
seja a célula de memória acessada
– comunicação é feita usando a memória global
Passo do algoritmo PRAM
P1 P2 P3 P4 Pn
Comunicação em uma máquina PRAM
d1
P1 P2 P3 Pn
d1 d2 d3 dn
PASSO 12
Observações
Problema: x∈V?
Ambiente: P processadores tipo EREW PRAM
Analisando o problema:
P1 lê x
P1 escreve x em M1
P2 lê M1
P2 escreve em M2
P3 e P4 lêem M1 e M2
P3 e P4 escrevem em M3 e M4
P5, P6, P7 e P8 lêem M1, M2, M3 e M4
P5, P6, P7 e P8 escrevem M5, M6, M7 e M8
e assim por diante
x x x x x
M1 M2 M3 M4 M5 M6 M7 M8
P1 P2 P3 P4 P5 P6 P7 P8
x x x x x x
Por que a simulação? O simulação pode ser necessária caso uma das
razões aconteça:
– se os computadores paralelos disponíveis são do tipo EREW -
então executar algoritmos tipo: CREW e CRCW através de
simulação
CW comum:
todos processadores podem escrever no mesmo local de memória
global se o valor for o mesmo.
Suponha que Pi queira escrever o valor ai (1≤ i ≤ N)
variável auxiliar para cada processador Pi : bi
Simulando CW comum em um EREW
Dividindo a série ai em dois grupos
compare ai com ai+(N/2)
se forem iguais, Pi seta bi para verdadeiro (1)
5 5 5 5 5 5 5 5 1 1 1 1
P1 P2 P3 P4
=1 ? =1 ? 1= ? 1= ?
= ? = ?
&
1 1
&
= == 1 ? = == 1 ?
= ?
&1
= == 1 ?
Modelos Fortes e Fracos
O que quer dizer mais forte? Se um algoritmo é simulado em um
modelo mais fraco, o número de passos pode aumentar
Soma_PRAM_Pi (){
Para ( 1≤ h ≤ log n ) faça
se ( i ≤ n/2h ) faça
A[i] := A[2i] + A[2i -1];
}
32
17
4
7 3 10
8 2 10
15
9 1 0
5 5 46
21
6
9 3 10
12 2 25
11
4 7 14
11 3
P1 P2 P3 P4 P5 P6 P7 P8
7 10 10 5 9 12 11 14
17 15 21 25
32 46
78
Redução: Soma
para somar, log n iterações são necessárias, cada uma tem tempo
constante
é importante especificar
– o número máximo de processadores usados, como função da
entrada
– o modelo arquitetural sendo usado
Noções de Complexidade
Paralelismo Limitado
algoritmo p-paralelo se implementado em um modelo com p
processadores, fixo
T(n) e P(n): o tempo de execução e a quantidade de processadores do
algoritmo paralelo
se o número de passos é T(n) considerando p processadores, então
esse algoritmo é p computável neste tempo
se T(n) é polinomial e p é limitado superiormente por polinômio, então
o número de processadores é limitado polinomialmente, senão,
ilimitado
Algumas Definições
A - algoritmo paralelo
n - o tamanho da entrada
Princípio de Brent
P ro v a ??
Total de Operações: e Total de Processadores: p
Número
Unidade de
de Operações
Tempo P1 P2 Pk Pp
1 e1
2 e2
3 . . . . . .
e3
4
. e4
. .
.
.
.
T(n)
eT
ei ei ei
Tempo Total ≤ ∑ i
p
≤ ∑
i
+ 1
p
≤ p + T (n)
Outra vez: soma de n elementos
seja um modelo PRAM com p = 2q ≤ n = 2k processadores: P1,..., Pp
seja l = n/p = 2 k - q
Ps é responsável por A[l(s - 1) + 1] , …. , A[ls]
cada elemento é um vértice de uma árvore binária
o número de computações concorrentes corresponde ao número de
vértices em cada nível dividido pelos processadores disponíveis
Análise do Algoritmo
Seja o algoritmo em que n elementos são somados usando p
processadores (Obs.: O algoritmo só considera o trabalho de um dado
processador Ps:
primeiro passo: O(n/p) unidades de tempo
segundo passo?
Soma de n Elementos (JáJá)
Soma_Paralela_Ps ( A, p ){
for j =1 to l do /* l = n/p */
B(l(s - 1) + j): =A(l(s - 1) + j);
for h = 1 to log n do
if (k - h - q ≥ 0) then
for j = 2k-h-q(s - 1) + 1 to 2k-h-q s do
B(j): = B(2j - 1) + B(2j);
else if (s ≤ 2k-h) then
B(s): = B(2s - 1) + B(2s);
if (s = l) then S: = B(1);
}
Memória compartilhada
32
17
4
7 46
10
15
3 10
21
8 25
2
5 9 12
1 11
0 14
5 6 3 10 2 4 7 11 3
P1 P2 P3 P4
7 10 9 11
10 5 12 14
17 15 21 25
32 46
78
Perguntas:
1 2 3 4 5 R
Complexidade e Corretude do Algoritmo
como podemos provar que o algoritmo está correto?
simplesmente definimos um algoritmo e o executamos?
– seja h a altura máxima de uma árvore qualquer na floresta de árvores
enraizadas direcionadas
– por indução em h
– assim, no passo k
dk(i,S[j]) = 2 dk -1(i,S[i]) = 2 * 2k-1
Algoritmo Sequencial
Soma_Prefixos_Sequencial( x){
s1 := x1 ;
Para i = 2, …., n
si = si-1 ⊗ xi ;
}
Complexidade: O(n)
Soma de Prefixos
Definição
si = x1 ⊗ x2 ⊗ …. ⊗ xi
A[i] = xi
B[h,j] e C[h,j] onde 1 ≤ j ≤ n/2h (1 ≤ h ≤ log n especifica o nível)
ao final: sj = C[0,j]
Algoritmo Paralelo não Recursivo
Soma_Prefixos_Paralela_nRecursivo( A ){
1. Para 1 ≤ i ≤ n faça em // : B[0,j] := A[j];
2. Para 1 ≤ h ≤ log n faça
2.1 Para 1 ≤ j ≤ n/2h faça em //
2.1.1 B[h,j] := B[h - 1, 2j-1] * B[h - 1, 2j];
B[2,1]=B[1,1]+B[1,2 B[2,2]=B[1,3]+B[1,4
] ]
X1+X2+x3+x4 X5+X6+x7+x8
B[3,1]=B[2,1]+B[2,2
]
X1+X2+...+x7+x8
C[3,1]=B[3,1]
X1+X2+...+x7+x8
C[2,1]=B[2,1] C[2,2]=B[3,1]
X1+X2+x3+x4 X1+X2+...+x7+x8
Aplicação do Princípio
necessário saber quantas operações são executadas a cada passo
algoritmo de soma de prefixos com n = 2k - número de passos:
2log n + 2 ⇒ 2k+2
– qual o número de operações?
– qual o custo?
Princípio de Brent
w1,1 : número de operações no passo 1considerando o único loop
w2,m : número de operações executadas no passo 2 na m-ésima iteração
w3,m : número de operações executadas no passo 3 na m-ésima iteração
Então:
w1,1 = n
w2,m = n/2m = 2k /2m para 1 ≤ m ≤ k
w3,m = 2m para 0 ≤ m ≤ k
Assim:
w = w1,1 + ∑ w2,m + ∑ w3,m
w = n + ∑ n/2m + ∑ 2m
w = n + n(1-1/n) + 2n-1 = 4n-2
w = O(n)
Divisão e Conquista
usada quando identificamos problemas que podem ser particionados
em subproblemas menores, que são mais simples de serem resolvidos
CH(S)
envoltória superior
UH(S)
S
p
q
envoltória inferior
LH(S)
Divisão e Conquista Paralelo
p
q
Merging de duas envoltórias superiores
p
q
Merging de duas envoltórias superiores
Tangente Comum Superior
• sequencial – O(log n)
• busca binária
p
q
Algoritmo
Entrada: n pontos ordenados tais que x(p1) < x(p2) < .... <
x(pn)
Saída: UH(S)
8) O(1)
9) T(n/2)
10) TCS(UH(S1), UH(S2)) em O (log n)
Combinar as duas curvas dada a tangente produzindo S
– em O(1) com n processadores leituras concorrentes
serão realizadas.
Algoritmo
Explicar:
– ComplexidadeT(n) = O(log2 n) com O(n) processadores
Representação do problema
⇓
o objetivo deve estar especificado
Uma Classe de Problemas
classe de aplicações
– especificada pelo modelo da aplicação
Alguns conceitos
Tarefa – uma unidade de computação
No escalonamento global:
- migração – custoso e nem sempre usado (sala contexto, trasfere contexto
para o novo processador, reinicializa tarefa)
- geralmente se refere a balanceamento de carga
Balanceamento de Carga
sender-initiated receiver-initiated
P1 P2 P1 P2
Mais conceitos
Estático
conhecimento de características associadas às aplicações antes da execução
desta (estimativas)
relação de precedência entre os componentes da aplicação
Dinâmico
estimativas são conhecidas antes da execução e não as características
reais.
a especificação do escalonamento é feita ao longo da execução da
aplicação
– balanceamento de carga, por exemplo
Escalonamento Estático de Aplicações
pesos de execução em
pesos dos arcos em
0 4
2 8
4
5 2 3 7
1 2
1 3
2
4 6
5 6
5
4
6 3
Um Exemplo de GAD
Custos Unitários
2
1
3 9
4
5
10
6 8
7
11
Programação Distribuída
Introdução e Conceitos Básicos
Conceitos Básicos
Sistema Distribuído:
– Não há compartilhamento de memória
– Troca de informação através de troca de mensagens
Áreas de demanda:
– Otimização combinatória
– Mineração de dados
– Simulações
– Meteorologia
– Bioinformática
– Computação gráfica
Computação intensiva !!
Conceitos Básicos
Seqüencial Distribuído
Inst 1 Inst 1
Inst 2 Inst 2
... Inst 3
tempo
Inst x msg ...
tempo
... ...
... Inst z
... ...
... ...
Inst y Inst w
Conceitos Básicos
P(i) P(i)
P(j) P(j)
P(k) P(k)
Modelos de Computação
Assíncrono:
– Sem coordenação global
– Atraso na transmissão das mensagens é finito mas não determinado
– Desenvolvimento mais complexo
– Realístico
Síncrono:
– Com coordenação global
– Comunicação em “pulsos”
– Desenvolvimento mais simples
– Menos realístico
Modelo utilizado
CORRETUDE
Tempo de convergência:
– Síncrono: Nr. de pulsos
– Assíncrono: Maior cadeia de mensagens com relação de “causalidade”
Introdução ao MPI
Introdução
Eficiência na comunicação
Menos utilizada
Inst 1
Inst 2
Inst 3
...
...
msg
MPI_Bcast(....)
...
...
Algumas Funções para Comunicação Coletiva
MPI_Reduce: Combina todos os elementos presentes no buffer de cada
processo do grupo usando a operação definida como parâmetro e coloca o
valor resultante no buffer do processo especificado. O exemplo abaixo soma
todas as variáveis “x” armazenando o total na variável “tot” do processo 2.
#include <stdio.h>
#include <string.h>
#include “mpi.h”
if (my_rank != 0) {
sprintf(msg, “Processo %d está vivo!”, meu_rank);
destino = 0;
MPI_Send(msg,
strlen(msg)+1,
MPI_CHAR,
destino,
tag,
MPI_COMM_WORLD);
}
Programa Exemplo (3/3)
else { // if (my_rank == 0)
for (origem=1; origem<np; origem++) {
MPI_Recv(msg,
100,
MPI_CHAR,
origem,
tag,
MPI_COMM_WORLD,
&status);
printf(“%s\n”,msg);
}
}
MPI_Finalize( );
}
Alguns Algoritmos Distribuídos
•Propagação de Informação
•Propagação com Realimentação
•Integral Definida
•Conectividade em Grafos
•Distância Mínima
Grafo para testes
0
int matrizVizinhanca[6][6] = {
{0,1,1,0,0,0},
{1,0,1,1,1,0},
1 2 {1,1,0,0,0,1},
{0,1,0,0,0,0},
{0,1,0,0,0,0},
{0,0,1,0,0,0}
3 4 5 };
Propagação de Informações
Propagação de Informações
0
Nó 0 gera uma informação que
tem de ser encaminhada a todos
os demais.
1 2
3 4 5
Propagação de Informações - Algoritmo
Variáveis:
alcançado = falso
Ao receber inf
se alcançado = falso;
alcançado := verdadeiro;
envie inf a todos os vizinhos;
Propagação de Informações - Execução
0
Nó 0 gera uma informação e a
encaminha a todos os seus
vizinhos
1 2
3 4 5
Propagação de Informações - Execução
0
Nós 1 e 2 recebem a informação
e a encaminham a todos os seus
vizinhos
1 2
3 4 5
Propagação de Informações - Execução
0
Nós 3, 4 e 5 recebem a
informação e a encaminham a
todos os seus vizinhos
1 2
3 4 5
Propagação de Informações
0
Nó 0 gera uma informação e a
encaminha a todos os seus
vizinhos
1 2
3 4 5
Propagação de Informações - Execução
0
Nós 1 recebe a informação e a
encaminha a todos os seus
vizinhos mas canal de
1 2 comunicação 0 - 2 está muito
lento, e 2 recebe a informação de
1 antes de 0
3 4 5
Propagação de Informação - Complexidades
1 2 3 n
Propagação de Informação - Implementação
#include <stdio.h>
#include <mpi.h>
return contador;
}
Propagação de Informação - Implementação
/*programa principal*/
int main(int argc, char** argv)
{
int i;
int numeroDeVizinhos;
int myRank;
int source;
int tag = 50;
char message[100] = "Oi!";
MPI_Status status;
//inicialização do MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
numeroDeVizinhos = contaNumeroDeVizinhos(myRank);
Propagação de Informação - Implementação
if (myRank == 0) {
/*enviando para todos os vizinhos de myRank*/
for (i = 0; i < numeroDeTarefas; i++)
if (matrizVizinhanca[myRank][i] == 1)
{
printf("Enviando mensagem para %d\n", i);
MPI_Send(message, strlen(message)+1, MPI_CHAR, i,
tag,
MPI_COMM_WORLD);
}
// Finalização do MPI
MPI_Finalize();
}
Propagação de Informações com Realimentação
Propagação de Informações com Realimentação
0
Nó 0 gera uma informação que
tem de ser encaminhada a todos
os demais e recebe uma
1 2 confirmação quando a informação
já estiver completamente
disseminada.
3 4 5
Propagação de Informações com Realimentação - Algoritmo
Variáveis
pai := nil;
count := 0;
alcançado := falso;
Ao receber inf:
count := count +1;
se alcançado = falso
alcançado := verdadeiro;
pai := origem(inf);
envie inf a todos os vizinhos exceto pai;
se count := |vizinhos| e pai ≠ nil
envie inf para pai;
Propagação de Informações com Realimentação - Execução
0
Nó 0 gera uma informação e a
encaminha a todos os seus
vizinhos
1 2
3 4 5
Propagação de Informações com Realimentação - Execução
0
Nós 1 e 2 recebem a informação
e a encaminham a todos os seus
vizinhos, exceto pai
1 2
3 4 5
Propagação de Informações com Realimentação - Execução
0
Nós 3, 4 e 5 recebem a
informação e como são folhas, a
retornam para seus pais.
1 2
3 4 5
Propagação de Informações com Realimentação - Execução
0
Nós 1 e 2 receberam o retorno de
seus filhos e podem informar ao
seus pais
1 2
3 4 5
Propagação de Informações com Realimentação - Execução
0
Nó 0 recebeu o retorno de todos
os seus filhos e pode concluir
que todos os nós do sistema já
1 2 receberam a informação.
3 4 5
Propagação de Informações com Realimentação - Complexidade
1 2 3 n
Propagação de Informações com Realimentação - Implementação
#include <stdio.h>
#include <mpi.h>
return contador;
}
Propagação de Informações com Realimentação - Implementação
/*programa principal*/
int main(int argc, char** argv)
{
int i;
int numeroDeVizinhos;
int myRank;
int source;
int tag = 50;
int pai;
char message[100] = "Oi!";
MPI_Status status;
//inicialização do MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
numeroDeVizinhos = contaNumeroDeVizinhos(myRank);
Propagação de Informações com Realimentação - Implementação
if (myRank == 0)
{
/*enviando para todos os vizinhos de myRank*/
for (i = 0; i < numeroDeTarefas; i++)
if (matrizVizinhanca[myRank][i] == 1)
{
printf("Enviando mensagem para %d\n", i);
MPI_Send(message, strlen(message)+1, MPI_CHAR, i,
tag,
MPI_COMM_WORLD);
}
//Finalização do MPI
MPI_Finalize();
}
Integral Definida
Método do Trapezóide
Integral Definida
f(x)
∫ f(x) dx
b
a
a b x
Integral Definida – Método do Trapezóide
y
b1=f( x i-1 )
Área do trapézio = h (b1+b2) / 2
b2=f(x i )
f(x) h=(b-a)/n (constante)
a xi-1 xi b x
∫ f(x) dx =
b
a
x
Ação inicial para todos os nós:
x := local_a;
local_b(2)
local_b(0)=local_a(1)
local_b(1)=local_a(2)
local_a(0)
integral :=(f(local_a)+f(local_b))/2.0;
para i variando de 1 até local_n-1 faça
x := x + h;
integral := integral + f(x);
integral := integral * h;
Integral Definida - Algoritmo
se my_rank = 0
total := integral;
para i variando de 1 até nrProcessos – 1
receba valor na variável integral;
total = total + integral;
imprima “Valor calculado: “ + total;
senão
envie integral para nó 0;
Integral Definida - Implementação
#include <stdio.h>
#include <mpi.h>
main(int argc, char** argv) {
int my_rank;
int p; // número de processos
float a=0.0, b=1.0; // intervalo a calcular
int n=1024; // número de trapezóides
float h; // base do trapezóide
float local_a, local_b; // intervalo local
int local_n; // número de trapezóides local
float integral; // integral no meu intervalo
float total; // integral total
int source; // remetente da integral
int dest=0; // destino das integrais (nó 0)
int tag=200; // tipo de mensagem (único)
MPI_Status status;
Integral Definida - Implementação
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
h = (b-a) / n;
local_n = n / p;
local_a = a + my_rank * local_n * h;
local_b = local_a + local_n * h;
if(my_rank == 0) {
total = integral;
for(source=1; source<p; source++) {
MPI_Recv(&integral, 1, MPI_FLOAT, source, tag,
MPI_COMM_WORLD, &status);
total +=integral;
}
} else
MPI_Send(&integral, 1, MPI_FLOAT, dest,
tag, MPI_COMM_WORLD);
x = local_a;
for( i=1; i<=local_n-1; i++) {
x += h;
integral += f(x);
}
integral *= h;
return integral;
}
Integral Definida – Implementação
float f(float x) {
return fx;
}
Conectividade em Grafos
Conectividade em Grafos
1,2,3,4,5
0
O problema trata da desco-
0,2,3,4,5 berta, por cada nó, das
identificações de todos os
1 2 outros nós aos quais está
conectado.
0,1,3,4,5
3 4 5
Variáveis:
initiate = false;
para todos os nós k de N;
parent(k) := nil;
count(k) := 0;
reached(k) := false;
Ação se n ∈ N(0):
initiate := true;
reached(id) := true;
envie id para todos os vizinhos;
Conectividade em Grafos - Algoritmo
count(k) := count(k) + 1;
se reached(k) = false
reached(k) := true;
parent(k) := j;
para todos os vizinhos exceto parent(k)
envie id(k);
se count(k) = nr de vizinhos de i
se parent(k) ≠ nil
envie id(k) para parent(k)
nó pare cou reach
nt nt ed
#include <stdio.h>
#include <mpi.h>
int numeroDeTarefas = 8;
int matrizVizinhanca[8][8] = { {0,1,1,0,0,0,0,0},
{1,0,1,1,1,0,0,0},
{1,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,1,0,0,0,0,0,0},
{0,0,0,0,0,0,1,1},
{0,0,0,0,0,1,0,1},
{0,0,0,0,0,1,1,0},
};
Conectividade em Grafos – Implementação
return contador;
}
Conectividade em Grafos – Implementação
if(contador[myRank]!=numeroDeVizinhos) return 0;
else return 1;
}
Conectividade em Grafos – Implementação
/*programa principal*/
int main(int argc, char** argv)
{
int i, j;
int numeroDeVizinhos;
int myRank;
int source;
int tag = 50;
int pai[numeroDeTarefas];
int contador[numeroDeTarefas];
int reached[numeroDeTarefas];
int id;
int origem;
MPI_Status status;
Conectividade em Grafos – Implementação
//inicialização do MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
numeroDeVizinhos = contaNumeroDeVizinhos(myRank);
//inicializando variáveis
for (i=0; i<numeroDeTarefas; i++)
{
pai[i]=-1;
contador[i]=0;
reached[i]=0;
}
reached[myRank]=1;
Conectividade em Grafos – Implementação
if (contador[id]==numeroDeVizinhos)
if (pai[id]!=-1)
MPI_Send(&id, 1, MPI_INT, pai[id], tag,
MPI_COMM_WORLD);
}
//imprimindo resultado
printf("processo %d: Elementos conectados: ", myRank);
for (i=0; i<numeroDeTarefas; i++)
if (contador[i]!=0) printf("%d ", i);
printf("\n");
fflush(stdout);
//Finalização do MPI
MPI_Finalize();
}
Distância Mínima
Algoritmo Síncrono
Algoritmo Assíncrono
Distância Mínima
nó dist. first
nó dist. first 1 1 1
0 1 0 2 1 2
2 1 2
Ao final do algoritmo, cada
3 2 1
nó deve conhecer a
3 1 3 0 4 2 1 distância mais curta para
4 1 4 5 2 2 cada um dos demais, e
5 2 2 através de qual vizinho se
atinge outro nó com esta
1 2
distância.
nó dist. first
3 4 5 0 2 2
1 2 2
Por exemplo, estas são
2 3 2 as informações dos nós
3 3 2 0, 1 e 5.
4 3 2
Distância Mínima – Algoritmo Síncrono
Variáveis:
dist(i) := 0;
dist(k) := n para todo nó k ≠ i;
first(k) = nil para todo nó k ≠ i;
set = {id};
Entrada:
0<s≤n-1,
msg(s) com set`s recebidos de nós n(j);
set := {};
para cada set recebido em msg
para cada id(k) em set
se dist(k)>s
dist(k) := s;
first(k) := n(j);
set := set U {id(k)}
envie set para todos os vizinhos
Distância Mínima – Algoritmo Assíncrono
Variáveis:
dist(i) := 0;
dist(k) := n para todo nó k ≠ i;
first(k) := nil para todo nó k ≠ i;
set := {id};
level(j) := 0 para todos os vizinhos de i;
state := 0;
initiate := false;
Ação se n ∈ N(0):
initiate := true;
envie set para todos os vizinhos;
Distância Mínima – Algoritmo Assíncrono
Input: set(j);
Se initiate = false
initiate := true;
envie set para todos os vizinhos;
se state < n-1
level(j) := state + 1;
para cada id(k) em set
se dist(k) > level(j)
dist(k) := level(j);
first(k) := n(j);
Distância Mínima – Algoritmo Assíncrono
3 nil 6 -1 1 nil 6 -1
1 2
4 nil 6 -1 2 nil 6 ---
1 2
3 nil 6 ---
5 nil 6 ---
1 2
4 nil 6 ---
1
1 5 nil 6 -1
2
State=0
State=0 State=0
nó First Dist Level
nó First Dist Level nó First Dist Level
3 0 nil 6 --- 4
0 nil 6 --- 0 nil 6 ---
5
1 nil 6 -1
1 nil 6 -1 1 nil 6 ---
3 2 nil 6 --- 4 5
2 nil 6 --- 2 nil 6 -1
3 nil 6 ---
3 nil 6 --- 3 nil 6 ---
4 nil 6 ---
4 nil 6 --- 4 nil 6 ---
5 nil 6 ---
5 nil 6 --- 5 nil 6 ---
State=1
3 3 1 0 1 1 1 0
2,3,4 1,5
4 4 1 0 2 nil 6 ---
0,5
0,3,4 3 nil 6 ---
5 nil 6 ---
1 2
4 nil 6 ---
0,2,3 5 5 1 0
0,2,4
0,1
State=1
State=1 State=1
nó First Dist Level
nó First Dist Level nó First Dist Level
1 0 nil 6 --- 1
0 nil 6 --- 0 nil 6 ---
2
1 1 1 0
1 1 1 0 1 nil 6 ---
3 2 nil 6 --- 4 5
2 nil 6 --- 2 2 1 0
3 nil 6 ---
3 nil 6 --- 3 nil 6 ---
4 nil 6 ---
4 nil 6 --- 4 nil 6 ---
5 nil 6 ---
5 nil 6 --- 5 nil 6 ---
State=2
State=2
State=2 State=2
nó First Dist Level
nó First Dist Level nó First Dist Level
0,2,4 0 1 2 --- 0,2,3
0 1 2 --- 0,1 0 2 2 ---
1 1 2 1
1 1 1 1 1 2 2 ---
3 2 1 6 --- 4 5
2 1 2 --- 2 2 1 1
3 nil 6 ---
3 1 2 --- 3 nil 6 ---
4 1 2 ---
4 nil 6 --- 4 nil 6 ---
5 nil 6 ---
5 nil 6 --- 5 nil 6 ---
State=3
State=3
State=3 State=3
nó First Dist Level
nó First Dist Level nó First Dist Level
0 1 2 ---
0 1 2 --- 0 2 2 ---
1 1 2 2
1 1 1 2 1 2 2 ---
3 2 1 6 --- 4 5
2 1 2 --- 2 2 1 2
3 nil 6 ---
3 1 2 --- 3 nil 6 ---
4 1 2 ---
4 nil 6 --- 4 nil 6 ---
5 nil 6 ---
5 nil 6 --- 5 nil 6 ---
Distância Mínima – Implementação
#include <stdio.h>
#include <mpi.h>
return contador;
}
Distância Mínima – Implementação
/*programa principal*/
int main(int argc, char* argv[])
{
int i, j, contador;
int numeroDeVizinhos;
int myRank;
int source;
int tag=50;
int pai;
MPI_Status status;
int origem;
int state;//marca o pulso atual deste processo
int dist[numeroDeTarefas];//distância
int first[numeroDeTarefas];//primeiro nó no caminho
int set[numeroDeTarefas];
int level[numeroDeTarefas];//pulso dos meus vizinhos
Distância Mínima – Implementação
//inicialização do MPI
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myRank);
numeroDeVizinhos = contaNumeroDeVizinhos(myRank);
printf("iniciando...\n");
fflush(stdout);
//inicializando vetor dist e first
for (i=0; i<numeroDeTarefas; i++)
{ dist[i]=numeroDeTarefas;//considerado como infinito
first[i]=-1;
set[i]=0;
level[i]=0;
}
dist[myRank]=0;
set[myRank]=1;
state=0;
Distância Mínima – Implementação
//imprimindo as distâncias
printf("processo %d: ", myRank);
for (i=0; i<numeroDeTarefas; i++)
printf("dist(%d)=%d, ", i, dist[i]);
printf("\n");
printf("processo %d: ", myRank);
for (i=0; i<numeroDeTarefas; i++)
printf("first(%d)=%d, ", i, first[i]);
printf("\n");
fflush(stdout);
//Finalização do MPI
MPI_Finalize();
}
Exercício