Introdução ao Processamento de Alto Desempenho (PAD)stephan/CursoPAD-2.pdf · • Speedup Paralelo com P processadores: SP = T1 / TP ... S’ = (P-1) f + 1 Introdução ao Processamento

Introdução ao Processamento de Alto

Desempenho (PAD)

Celso L. Mendes / Stephan StephanyLAC /INPE

Email: [email protected]

Estrutura do Minicurso • 4 aulas em 3 dias

• 18-19-20 fevereiro 2020 10:20hs – 12:00hs• Material: notas de aula, capítulo do livro, referências• Material auxiliar de apoio: www.lac.inpe.br/~celso/elac19

• Instrutor: Stephan Stephany • Email: [email protected] ([email protected])• LAC, sala 12, fone 3208-6548• Currículo Lattes: http://lattes.cnpq.br/9051364483671452• Currículo Lattes: http://lattes.cnpq.br/1446664587151293

2Introdução ao Processamento de Alto Desempenho – PAD

Celso L. Mendes (LAC/INPE)

http://www.lac.inpe.br/~celso/elac19

mailto:[email protected]

http://lattes.cnpq.br/9051364483671452

Estrutura do Minicurso • Aula 2

3. Conceitos Fundamentais em PADi. Lei de Moore

ii. Pipeline e Vetorização

iii. Speedup e Eficiência

iv. Leis de Amdahl e Gustafson

v. Balanceamento de Carga



Conceitos Fundamentais em PAD

• Processamento de Alto Desempenho (PAD):• Sub-área da Computação

• Vários conceitos tradicionais permanecem úteis

• Alguns destes conceitos se aplicam tanto a sistemas monoprocessados como aos multiprocessados• Mesmo em sistemas paralelos, é importante otimizar o

desempenho do processamento sequencial• Sistemas paralelos são compostos de sub-componentes que

podem ser sistemas sequenciais tradicionais



Lei de Moore • Projeção feita na década de 60:

• Densidade de components dobra a cada dois anos!• Percepção popular: dobro de velocidade nos processadores



Lei de Moore (cont.) • Problema: energia α frequência2

• 2004: Manter os aumentos de frequência de antes é proibitivo!

6

Número de Núcleos

Consumo

Frequência

Desempenho por Núcleo

Número de Transistores(lei de Moore)

Introdução ao Processamento de Alto Desempenho – PADCelso L. Mendes (LAC/INPE)

Lei de Moore (cont.) • Conclusões:

• Lei deMoore continua valendo até hoje!• Densidade de componentes (número de transistores por área

de pastilha) continua dobrando a cada dois anos• Frequência de relógio parou de aumentar por causa da energia

consumida, e do calor dissipado

• Novos transistores são usados para replicar os núcleos dos processadores• Início da era multi-core: múltiplos núcleos por pastilha• Desafio: como aproveitar os vários núcleos?



Pipeline • Princípio Básico:

• Aumento de eficiência via linha de montagem tradicional• Idéia: quebrar tarefa complexa em sub-tarefas simples• Executar sub-tarefas em sequência• Cada sub-tarefa é feita por uma unidade especializada

• Paralelismo: várias unidades em funcionamento• Ganho de desempenho:

• Não é preciso esperar uma tarefa terminar totalmente para iniciar a tarefa seguinte



Pipeline (cont.)

9

Exemplo: Tarefa A-B-C-D

Sub-tarefas A, B, C, D

Caso Típico: Exec. Instruções

A = Busca da Instrução

B = Decodificação

C = Acesso aos Operandos

D = Execução da Operação


Pipeline (cont.) • Observações:

• Tempo total de cada tarefa não muda …• Mas o tempo total de N tarefas é bem menor• Supondo N tarefas, cada uma composta de K sub-tarefas:

• Tempo sem pipeline: N × K ciclos• Tempo com pipeline: K + (N-1) ciclos• Ganho de desempenho com pipeline: (N × K)/(K + N - 1)

• Se N»K : K + N - 1 ≈ N e então Ganho ≈ K

10

Ganho de desempenho com pipeline ≈ Número de estágios no pipeline


Pipeline (cont.) • Possíveis complicações práticas:

1. Tempos das sub-tarefas podem não ser iguais• Algumas sub-tarefas podem sofrer atrasos

Exemplo: “C” pode sofrer atraso no acesso `a memória

• Estes atrasos são conhecidos como bolhas no pipeline• Enquanto a bolha perdurar, não há processamento útil !

2. Uma sub-tarefa pode precisar usar como entrada algum dado ainda não disponível

Exemplo: Ci poderia precisar acessar dado calculado por Di-1

• Soluções de hardware: (a) travar o pipeline; (b) redirecionar dado



Vetorização • Princípio Básico:

• Processar vários operandos através de uma única instrução

• Caso TípicoC(1)=A(1)+B(1)

C(2)=A(2)+B(2)

. . .

C(N)=A(N)+B(N)

ou C(1:N)=A(1:N)+B(1:N)

• Execução: N iterações do loop, 6 instruções por iteração: 6.N instruções• Cada instrução precisa passar por busca, decodificação, etc.

12

Instruções de máquina geradas: base=1Loop: load A(base) R1 load B(base) R2 add R1+R2 R3 store R3 C(base) base=base+1 if (base≤N) jump(Loop)


Vetorização (cont.) • Implementação com Instruções Vetoriais:

loadv A(base) V1

loadv B(base) V2

addv V1+V2 V3

storev V3 C(base)

• V1, V2, V3, etc: registros vetoriais, de comprimento L

• Unidades aritméticas capazes de operar sobre V1, V2, etc• Novo total de instruções: 4

• Se N for maior que L, montar um laço em torno das instruções acima, com N/L iterações



Vetorização (cont.) • Exemplo: Cray-1

14

8 Registros Vetoriais (V0,V1,…,V7)

64 Elementos em cada registro

64 bits por elemento

Unidades Funcionais:

Operações Vetor-Vetor ou

Vetor-Escalar


Vetorização (cont.) • Otimizações: encadeamento (chaining)

• Exemplo: D(1:N)=A(1:N)+B(1:N)+C(1:N)• Implementação

loadv A(base) V1

loadv B(base) V2

loadv C(base) V3

addv V1+V2 V4

addv V4+V3 V5

storev V5 D(base)

• Não é necessário esperar o término de toda a primeira soma para iniciar a segunda soma• Assim que o primeiro elemento de V1+V2 for produzido, a segunda soma pode ser

iniciada! (resultados vão para V4 e para a outra unidade functional)



Vetorização (cont.) • Possíveis Complicações: Exemplo: do i=2,N

A(i)=A(i-1)+B(i) enddo

Implementação “descuidada”:loadv A(base-1) V1loadv B(base) V2addv V1+V2 V3storev V3 A(base)

Resultado será errado Valores de A não foram atualizados !• Um bom compilador não irá vetorizar este laço

16

A(2)=A(1)+B(2) A(3)=A(2)+B(3) A(4)=A(3)+B(4) . . .


Vetorização (cont.) • Compiladores Vetorizadores

• Geram código vetorizado sempre que possível• Emitem relatório de laços onde não é possível vetorizar

• Causa mais freqeunte é a dependência entre iterações• Alterniativa: mudar estrutura do laço

• Amadurecimento dos compiladores foi fundamental para o sucesso dos sistemas vetoriais

• Sem vetorização, é impossível chegar perto do desempenho de pico do sistema (desempenho obtido fica uma ordem de grandeza abaixo do pico, ou pior)



Vetorização (cont.) • Exemplo-2: Processadores Intel x86

• Vetorização presente com extensões SSE e sucessores• SSE: Streaming SIMD Extension• Suporte de hardware, registros vetoriais com L=4 ou mais

• Mesmo conceito das máquinas vetoriais antigas: Uma única instrução dispara várias operações em conjunto

• Compilador Intel atual tem extenso suporte a vetorização• Em alguns casos pode ser necessário ajudar o compilador

• Reestruturação dos código, eliminando dependências• Garantia pelo programador de que não há dependências



Speedup • Conceito: Speedup = Ganho de Desempenho

• Pode ser o resultado de uma otimização qualquer• Exemplos:

• Utilização de um novo algoritmo num programa sequencial• Uso de chaves de compilação• Uso de mais processadores (speedup paralelo)

• Caso Geral:Speedup = tempo_original / tempo_otimizado



Speedup Paralelo• Ganho de desempenho pelo uso de mais processadores

• Tempo de execução com 1 processador: T1

• Tempo de execução com P processadores: TP

• Speedup Paralelo com P processadores: SP = T1 / TP

Situação ideal: TP = T1 / P SP = P• Difícil de se obter na prática

• Paralelização introduz overheads que não existiam antes

• Caso mais comum: SP < P

• Casos patológicos: SP > P (speedup superlinear)• Resultante de fatores especiais, tais como acesso à memória, etc.



Eficiência Paralela• Definição: EP = SP / P

• Medida do grau de efetividade dos processadores em uso

Situação ideal: SP = P EP = 1.0

• Caso mais comum: SP < P EP < 1.0

• Em geral, tanto SP como EP são funções de P

21

EPSP

P P

1.0

Ideal: SP=P

Ideal: EP=1


Lei de Amdahl • Determina limites no speedup de programas reais

• Programa sequencial: TS = TA + TB

A: Parte estritamente sequencial

B: Parte paralelizável (pode-se assumir totalmente paralelizável)

f: fração paralelizável = TB / (TA+TB) , f < 1.0

• Execução com P processadores: TP = TA + TB / P

• Speedup: SP=TS /TP=(TA+TB)/(TA+TB /P)

com P ∞ : SP-->∞= (TA+TB)/TA = 1 / (1-f)

22

SP(max) = 1 / (1-f)


Lei de Amdahl (cont.)• Limite do Speedup:

• Mesmo com número infinito de processadores !• Limite do speedup depende da fração paralelizável f

23

SP(max) = 1 / (1-f)

f SP(max)

0,5 2,0

0,8 5,0

0,9 10,0

0,95 20,0

0,99 100,0 1% serial, 99% paralelizável

P=∞: Speedup = 100

50% serial, 50% paralelizável

P=∞: Speedup = 2


Lei de Gustafson • Extensão da Lei de Amdahl – casos práticos

• Novo cenário de execução: TS = TA + TB

aumentando o problema P vezes TS’ = TA + P . TB

Nova execução paralela: TP’ = TA + P . TB / P = TA + TB

Speedup em escala: S’ = TS’ / TP’ = (TA + P . TB ) / (TA + TB ) = (1-f)+P.f

Speedup em escala (Gustafson):• Não é mais função de f apenas; bem mais próximo do speedup ideal (P)

• Aumentando P (número de procs e tamanho do problema), speedup aumenta!

24

S’ = (P-1) f + 1


Lei de Gustafson (cont.)

• Implicações da Lei de Gustafson• Speedup em escala S’ bem mais próximo do ideal (P)

25

f S’ , P=2 S’ , P=10 S’ , P=100

0,5 1,5 5,5 50,5

0,8 1,8 8,2 80,2

0,9 1,9 9,1 90,1

0,95 1,95 9,55 95,5

0,99 1,99 9.91 99,1


Leis de Amdahl × Gustafson

• Lei de Amdahl: escalabilidade forte• Aumento de P é usado para resolver o mesmo problema• Execução paralela leva tempo mais curto que a serial• P crescente: tamanho de problema fixo, TP diminui• Exemplo: dinâmica molecular (número fixo de átomos)

• Lei de Gustafson: escalabilidade fraca• Aumento de P é usado para resolver problema P vezes maior• Execução paralela leva o mesmo tempo que a serial• P crescente: tamanho de problema crescente, TP fixo• Exemplo: previsão de tempo (grade de maior resolução)



Balanceamento de Carga

• Importância do Balanceamento• Em muitas aplicações paralelas: P processadores sincronizados • Atrasos em alguns processadores têm impacto em todos• Mesmo que um único processador atrase, todos sofrem

• Demais processadores ficam ociosos esperando pelo atrasado

• Causas de desbalanceamento• Divisão de trabalho inapropriada• Fatores dinâmicos imprevisíveis ao longo da execução



Balanceamento de Carga (cont.)

Exemplo de desbalanceamento: BRAMS (previsão do tempo)

28

Previsão meteorológica Carga em 64 processadores



• Formas de balanceamento possíveis• Balanceamento estático

• Dividir domínio entre os processadores de acordo com a carga esperada em cada processador• Requer conhecimento prévio sobre a carga• Assume que a carga não muda durante a execução

• Balanceamento dinâmico• Medir continuamente a carga nos processadores• Redividir a carga pelos processadores quando necessário• Pode ser feito dentro ou fora da aplicação




• Exemplo de desbalanceamento: BRAMS, P=64• Gráficos da utilização média de cada processador

(100% = proc. ocupado, 0%=proc. ocioso)



Execução original sem balanceamento Comportamento após o balanceamento

Fonte: E.Rodrigues et al, HiPC’2010

BRAMS - Escalabilidade

• Speedup medido com até 9600 processadores• Dinâmica x Física: Física escala melhor!

(dinâmica tem comunicação!)



Fonte: Jairo Panetta

Física

Dinâmica

Em Resumo:• Lei de Moore: Dobro de componentes por pastilha a cada dois anos

• Até 2004: maior frequência; após 2004: mais núcleos (multi-core)

• Pipeline: quebrar tarefa em sub-tarefas• Ganho de desempenho ≈ número de sub-tarefas (estágios)

• Vetorização: instrução opera sobre conjunto de operandos

• Speedup: SP=T1 /TP Eficiência: EP=SP /P

• Amdahl: SP(max)=1/(1-f) Gustafson: S’=(P-1) f+1• Escalablidade forte: tam.problema fixo × Escalabilidade fraca: tempo fixo

• Balanceamento de Carga: um processador sobre-carregado já é fatal



Documents

Introdução ao Processamento de Alto Desempenho (PAD)stephan/CursoPAD-2.pdf · • Speedup Paralelo com P processadores: SP = T1 / TP ... S’ = (P-1) f + 1 Introdução ao Processamento