Exercícios (Ian Foster’s Book)
1) If today's workstations execute at operations per second, and performance increases at a rate of 25 percent per year, how long will it be before we have workstations capable of operations per second?
2) A climate model requires floating point operations for a ten-year simulation. How long would this computation take at floating point operations per second (10 Mflops)?
3) A climate model generates bytes of data in a ten-day simulation. How fast must data be transferred to secondary storage? What transfer rate is required if we are to search this data in ten minutes?
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
Maior facilidade de programação: o esforço intelectual é reduzido quando nos concentrarmos em "uma coisa de cada vez”
duas dimensões:
– dimensão espacial
– dimensão temporal
Dimensão Espacial
A cada momento, conjuntos de tarefas independentes são implementadas – cada tarefa ou processador não sabe o que acontecerá "a seguir"
detalhamento de informações globais levam a uma programação difícil
Dimensão Temporal
programas são composições de ações seqüenciais que preenchem o sistema computacional como um todo:
pode-se definir com maior conhecimento o que vai acontecer a seguir
Níveis de Paralelismo
Dependendo do nível considerado, a exploração do paralelismo é diferente
nível de aplicações ou fases de aplicações a nível de tarefas a nível de instruções - a execução da instrução necessita da busca, análise e
execução propriamente dita dentro dos circuitos aritméticos
Algoritmos
Quando queremos resolver um problema computacionalmente, temos que analisar a complexidade deste. No domínio seqüencial, se procura definir um algoritmo que resolva o problema em tempo mínimo.
Mas quando se tratando de algoritmos paralelos, mais um parâmetro – número de processadores – operações independentes devem ser executadas em paralelo.
qual o tamanho dos processos? noção de granulosidade (granularity) – a razão entre o tempo de computação necessário para executar
uma tarefa e a sobrecarga de comunicação durante essa computação.
Modelos de Computação
Modelo de Computação Seqüencial: von Neumann plataforma base para que usuários e projetistas
– complexidade de tempo do pior caso: tempo máximo que o algoritmo pode levar para executar qualquer entrada com n elementos
– complexidade de tempo esperado: complexidade média – critério de custo uniforme: qualquer instrução RAM leva uma unidade
de tempo para ser executada e também o acesso a registradores Modelo de Computação Paralela O desempenho do programa paralelo depende de certos fatores
dependentes da máquina: – grau de concorrência; – escalonamento e alocação de processadores; – comunicação e sincronização.
Modelo PRAM – modelo ideal
conjunto de p processadores operando sincronamente sob o controle de um único relógio, compartilhando um espaço global de memória
algoritmos desenvolvidos para este modelo geralmente são do tipo SIMD – todos os processadores executam o mesmo conjunto de instruções,
e ainda a cada unidade de tempo, todos os processadores estão executando a mesma instrução mas usando dados diferentes.
Modelo PRAM – modelo ideal
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
fase de leitura: os processadores acessam simultaneamente locais de memória para leitura. Cada processador acessa no máximo uma posição de memória e armazena o dado lido em sua memória local
fase de computação: os processadores executam operações aritméticas básicas com seus dados locais
fase de gravação: os processadores acessam simultaneamente locais de memória global para escrita. Cada processador acessa no máximo uma posição de memória e grava um certo dado que está armazenado localmente
Modelo PRAM
análise e estudo de algoritmos paralelos
definição de paradigma de programação paralela
avaliação do desempenho desses algoritmos independentemente das máquinas paralelas
se o desempenho de um algoritmo paralelo para o modelo PRAM não é satisfatório, então não tem sentido implementá-lo em qualquer que seja a máquina paralela
se eficiente, no entanto, podemos simulá-lo em uma máquina real : simulação deve ser eficiente
Padrões de Acesso no Modelo PRAM
Exclusive Read (ER): vários processadores não podem ler ao mesmo tempo no mesmo local
Exclusive Write (EW): vários processadores não pode escrever no mesmo local de memória
Concurrent Read (CR): vários processadores podem ler ao mesmo tempo o mesmo local de memória
Concurrent Write (CW): vários processadores podem escrever no mesmo local de memória ao mesmo tempo
Combinações são usadas para formar as variantes do PRAM: EREW, CREW, ERCW e CRCW
Prioridades do CRCW
Para resolver conflitos no caso de vários processadores tentarem escrever ao mesmo tempo no mesmo local de memória global:
Comum - vários processadores concorrem a escrita no mesmo local de memória global durante o mesmo instante de relógio - todos devem escrever o mesmo valor;
Arbitrário - dentre os vários processadores, um é selecionado arbitrariamente e seu valor armazenado no local de memória disputado;
Prioridade - dentre os vários processadores, aquele com o menor índice é escolhido para escrever o seu valor no local concorrido.
Memória Global
P1 P2 P3 P4 Pn
Comunicação em uma máquina PRAM
Comunicação através da memória global: Pi quer passar x para Pj
– Pi escreve x em um local de memória global em um determinado passo
– Pj pode acessar o dado naquele local no próximo passo
d1 d1
Memória compartilhada
P1 P2
d2
P3
d3
Pn
dn
Passo 1: cada processador realiza sua computação
d1 d1
Memória compartilhada
P1 P2
d2
P3
d3
Pn
dn
Passo 1: P1 escreve na memória
d1
Observações
os processadores operam sincronamente: a cada passo, todas os processadores executam a mesma instrução sobre dados distintos
uma instrução pode ser simplesmente uma operação aritmética ou uma comparação de dois números
processadores ativos: somente um subconjunto de processadores executem uma instrução e processadores restantes ficam ociosos/inativos
Exemplo V ⇒ vetor com n elementos. x ⇒ um dado valor
Problema: x ∈ V ? Ambiente: P processadores tipo EREW PRAM
Analisando o problema:
todos os processadores tem que saber o valor de x não podem acessar a célula de x simultaneamente depois, cada processador tem que olhar os elementos de V sinalização da localização do valor x no vetor V
Solução
todos os processadores devem saber sobre x: broadcasting ou difusão
Pior caso deste procedimento log2 P passos – P1 acessa a memória global: – P2 comunica com P1 ou seja, de alguma forma, P1 informa x para
P2 – P1 e P2 informam x para P3 e P4 – assim por diante
processadores não têm permissão de acesso simultâneo ⇒ gravam x em lugares distintos: Mi é um dos P locais de memória global
Um vetor M auxiliar é utilizado
Solução do broadcasting (leitura)
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
a cada passo: duas vezes o número de processadores ativos do passo anterior podem ler e escrever ⇒ log P passos
broadcasting
P1 lê de x;
P1 escreve em M[1]; Para h:= 1 até log P faça {
se 2h-1 < i ≤ 2h então {
Pi lê de M[i - 2h-1]; Pi escreve em M[i];
}
}
x x x
Memória compartilhada
P1
x
PASSO 1
x
P2
x
x
x
x
x
P3
x
P4
x x
P5 P6 P7 P8
x x
x x
PASSO 2 PASSO 3 PASSO 4
M1 M2 M3 M4 M5 M6 M7 M8
A Procura
o vetor V é divido em P pedaços: S1, S2, …, SP – Pi procura por x em Si – pior caso: n/P passos
Total: log P + n/P passos, no pior caso
Como o algoritmo poderia ser melhorado?? – Definição de uma variável Achou
Com computador mais poderoso ⇒ algoritmo mais rápido.
PRAM mais poderoso: CREW PRAM para achar x, o algoritmo executa n/P passos leituras concorrentes são permitidas
– todos os processadores podem acessar x em um passo – todos os processadores podem consultar Achou em um passo – mas ao encontrar, o processador tem que atualizar Achou
Quantos passos nas seguintes situações? – somente um dos elementos tem valor x – x pode ser um valor repetido em V
• mais de um processador pode atualizar Achou simultaneamente.
Relações entre Modelos
EREW PRAM ⇒ mais fraco
CREW PRAM ⇒ pode executar EREW na mesma quantidade de tempo – simplesmente leituras concorrentes não são feitas
CRCW PRAM ⇒ pode executar EREW na mesma quantidade de tempo – simplesmente leituras concorrentes não são feitas
Simulando Múltiplos Acessos em EREW
um só processador pode acessar a um local de memória a em um determinado instante
o modelo é bastante flexível – pode ser executado em qualquer outra PRAM – permite a simulação de múltiplos acessos mesmo que o espaço de
armazenamento aumente ou o tempo de execução aumente
Simulando Múltiplos Acessos em EREW
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
– para computadores paralelos com um grande número de processadores:
• o número de processadores que podem acessar a um mesmo local de memória simultaneamente é limitado
Simulando CW comum em um EREW
N acessos simultâneos por um EREW PRAM por N processos no mesmo local – leituras simultâneas: valor difundido, conforme já descrito: log N
passos – escritas simultâneas: procedimento simétrico à difusã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
! ???? ! É que vamos chamar de redução: comparamos vários para chegar a
uma resposta ! Precisamos de uma variável auxiliar?
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
CR ⇒ N leituras podem ser feitas concorrentemente ER ⇒ uma leitura é feita por mais de uma passo
[EcKstein,1979][Vishkin,1983] p processadores CRCW com prioridade, é simulado por um EREW PRAM com complexidade de tempo aumentado por um fator Θ (log p).
em um CRCW com prioridade, os acessos simultâneos seria imediatos, mas não no EREW
Algoritmos PRAM
para um problema: se um algoritmo PRAM tem complexidade de tempo menor que a do algoritmo seqüencial ótimo, então o paralelismo pode ser usado
Como iniciar um algoritmo PRAM: ativar os P processadores que farão parte da computação – os processadores serem ativados um a um – através do algoritmo de difusão: log P passos
depois da ativação, o algoritmo paralelo pode ser executado
Identificando Paralelismo
paradigmas de computação paralela
algoritmos aqui falados consideram o modelo PRAM. Exemplos:
Árvore Binária: o fluxo de dados (e controle) se dá da raiz até as folhas – Difusão: a partir de um processador, o fluxo (controle ou dados)
passa para dois processadores e assim, dobrando a cada iteração. – Divisão e Conquista: um problema é subdividido em subproblemas
cada vez menores
ou contrário, das folhas até a raíz: – Redução: dado n valores, a operação X é uma binária associativa
Redução: Soma
soma de n elementos: A = < 4, 3, 8, 2, 9, 1, 0, 5, 6, 3, 10, 2, 4, 7, 11, 3>
Soma_PRAM_Pi (){
Para ( 1≤ h ≤ log n ⎤ ) faça
se ( i ≤ ⎡n/2h ⎤ ) faça
A[i] := A[2i] + A[2i -1];
}
A[i] := A[2i] + A[2i -1]; ⇒ leitura: A[2i] e A[2i -1]; computa: A[2i] + A[2i -1];
escreve: A[i]
3 4
P1 P2 P3 P4 P5 P6 P7 P8
4 3 8 2 9 1 0 5 6 3 10 2 4 7 11 3
Memória compartilhada
8 2 9 1 0 5
7 7 10 10
6 3 10 2 4 7 11 3 9
10 10 5 5 9 9 12 12 11 11 14 14
7 10 10 5
25
12 11 14
17 15 21 17 15 21 25
17 15 21 25
32 46 32 46
32 46
78 78
Redução: Soma
primeiro loop: não há necessidade de mais do que ⎡n/2 ⎤ processadores
processadores acessam dois locais de memória simultaneamente, mas distintos
processadores escrevem em um local de memória (cada) simultaneamente, mas distintos
para somar, log n iterações são necessárias, cada uma tem tempo constante
Complexidade do Algoritmo: O ( log n) com O ( ⎡n/2 ⎤ ) processadores
Exercícios
Capitulo I do Jájá exercícios 1.5 e 1.8
Noções de Complexidade
Existem algoritmos PRAM cuja complexidade de tempo é menor do que o algoritmo correspondente seqüencial ótimo, mas podem desempenhar mais operações do que o seqüencial
Complexidade de tempo do pior caso em função do tamanho da entrada. Cada passo corresponde: – uma fase de computação – uma fase de comunicação
é 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
Custo do Algoritmo Paralelo produto tempo-processador T(n) × P(n)
– ignora ociosidade de processador
Algoritmo paralelo de custo ótimo: Ts = T(n) × P(n)
– Ts o tempo de execução do melhor algoritmo seqüencial
p < P(n) processadores: cada processador executa sequencialmente o que P(n)/ p processadores executam – T(n) × P(n)/p unidades de tempo
A - algoritmo paralelo n - o tamanho da entrada
Algumas Definições
Speedup , dado o número de processadores p
Se o S(A(n),p) é linear então todos os processadores são efetivamente utilizados – difícil de ser alcançado devido a natureza dos algoritmos e do
ambiente computacional paralelo
– difícil decompor o algoritmo em tarefas completamente independentes, onde cada tarefa leva Ts /p unidades de tempo para ser executada
Algumas Definições
Eficiência do algoritmo paralelo
razão entre S(A(n),p) e o número de processadores p E(A(n),p) = S(A(n),p)/p
– mostra como os processadores são efetivamente utilizados: quanto maior, melhor a utilização de cada processador
se E(A(n),p) = 1 o algoritmo paralelo é de custo ótimo (por que?)
Algumas Definições
Eficiência do algoritmo paralelo
razão entre S(A(n),p) e o número de processadores p E(A(n),p) = S(A(n),p)/p
– mostra como os processadores são efetivamente utilizados: quanto maior, melhor a utilização de cada processador
se E(A(n),p) = 1 o algoritmo paralelo é de custo ótimo (por que?) E(A(n),p) = S(A(n),p)/p E(A(n),p) = (Ts/Tp)/p " sendo de custo ótimo, Ts = Tp × p , então: E(A(n),p) = (Tp × p /Tp)/p = 1
Algumas Definições
Trabalho de um Algoritmo Paralelo
um algoritmo é descrito como uma seqüência de unidades de tempo, onde em cada unidade um conjunto de instruções concorrentes
trabalho de um algoritmo paralelo é o número total de operações executadas, não incluindo os tempos ociosos de certos processadores
são somadas, a cada unidade de tempo, o número de operações concorrentes podem estar sendo executadas
Exemplo: soma de n elementos T(n) e P(n): n/2 processadores executam em O(log n) unidades de
tempo Custo de O(n log n) em O(log n) unidades de tempo
Usando p < P(n) processadores: O(n log n/p)
• 1a unidade de tempo - n/2 operações (somas em paralelo)
• 2a unidade de tempo - n/4 operações (somas em paralelo)
• 3a unidade de tempo - n/8 operações (somas em paralelo)
• j-ésima unidade de tempo - n/2j operações
Total de operações: ∑O(log n) n/2j = O(n)
..............
Reduzindo o número de processadores
Princípio de Brent
“ Qualquer algoritmo paralelo com complexidade de tempo T(n) usando um número suficientemente grande de processadores e que ainda consistindo de O(e) operações elementares, pode ser implementado em p processadores com complexidade de tempo
O( ⎡e/p⎤ + T(n))
Prova??
P2 Pp P1
. . . . . .
Total de Operações: e Total de Processadores: p
Unidade de
Tempo
1
2
3
4
.
.
.
T(n)
Número de
Operações
e1
e2
e3
e4
.
.
.
eT
Pk
Tempo Total
Fixando o número de processadores: soma de n elementos
Seja um modelo PRAM com p = 2q ≤ n = 2k processadores: P1,..., Pp
proponha um algoritmo paralelo para p processadores
Fixando o número de processadores: soma de n elementos
Seja um modelo PRAM com p = 2q ≤ n = 2k processadores: P1,..., Pp Seja l = n/p = 2s é 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á) – algoritmo do processador Ps 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);
}
O que acontece com N = 8 e p = 2? (passo a passo) 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);
}
P3 P2
0
P4
0 11
11
P1
Memória compartilhada
3 2 1 5 3 2 7 3 8 10 11 9 4 4 6 4 3 8 2 9 1 5 6 3 10 2 4 7 11 3
7
10
10
5
9
12
11
14
7
10
10
5
9
12 14
7 10 10 5 9 12 14
17 15 21 25 17 15 21 25
17 15 21 25
32 46
32 46
32 46
78 78
Modelando soma paralela de n números
+
+ + + + + + + +
+ + + +
+ +
Perguntas:
qual o número de operações? qual o trabalho? qual o custo complexidade? tipo do PRAM? teria alguma outra versão com um menor de trabalho ou custo? qual o número de comunicações?
1 Responda as perguntas considerando as duas versões discutidas na sala de aula
2 especificar o pseudo-algoritmo da segunda versão discutida.
Implementação I – soma de n números
através de threads, implementar a soma de n números - em um número qualquer de processadores - em um número fixo de processadores
vantagens e desvantagens?