Utilização de técnicas de análise estática e dinâmica para ... - UFMG

Introdução As GPUs Tese Profiling Análise estática Otimização 

Utilização de técnicas de análise estática e 

dinâmica para otimização de aplicações de 

propósito geral em GPUs 

Bruno Rocha Coutinho 

Departamento de Ciência da Computação 

Universidade Federal de Minas Gerais 

coutinho@dcc.ufmg.br 

5 de julho de 2011


Introdução 

• Em computação há uma demanda praticamente infinita por 

desempenho: 

• Simulações cada vez mais complexas 

• Análise de grandes volumes da dados


Exemplos: Simulação de vírus


Exemplos: Simulação Climática


Exemplos: Análise de dados do LHC


Desenvolvimento de aplicações de alto desempenho


Utilização de GPUs em aplicações de alto desempenho 

• Evolução das GPUs para executar qualquer aplicação 

• Uso de GPUs para aplicações de propósito geral 

• Baixo custo 

• Alto desempenho 

• Exploração de todo potencial das GPUs é complexo 

• Há uma demanda por ferramentas para facilitar a otimização 

de aplicações em GPUs


História das GPUs 

• 1995: Dispositivos de funções fixas 

• 2001: Dispositivos programáveis 

• Shaders 

• 2004: Primeiras aplicações de propósito geral 

• Linguagens/APIs de computação gráfica 

• 2007: CUDA 

• Primeira linguagem de propósito geral para GPUs 

• Ascensão do paradigma de programação GPGPU.


GPUs: hardware voltado à throughput 

• Feitas para cargas regulares e massivamente paralelas 

• Não utiliza mecanismos para acelerar código serial, tais como: 

• Caches grandes 

• Execução de instruções fora de ordem 

• ALUs muito complexas 

• Arquitetura muito mais eficiente para aplicações paralelas 

Control 

Cache 

DRAM 

CPU 

ALU 

ALU 

ALU 

ALU 

DRAM 

GPU


Por que é difícil aproveitar todo o potencial da GPU? 

• Gerenciamento de memória 

• Movimentação de dados entre CPU e GPU 

• Disposição dos dados na memória da GPU 

• Grande número de unidades de processamento (512) 

• Esconde latência executando outras threads 

• 24000 threads para ter ocupação total 

• Arquitetura SIMD (Single Instruction Multiple Data) 

• Restrições no fluxo de controle 

• Carência de ferramentas para auxiliar os desenvolvedores. 

• Por exemplo: Visual Profiler da Nvidia 

• Em geral estas ferramentas ainda são muito primitivas.


Divergências 

• GPUs combinam threads em grupos que seguem o modelo 

SIMD 

• Estas threads executam em passo único (lock-step) 

• Eventualmente, num desvio, algumas threads executam o 

“then” e outras o “else” 

• Passo 1: Threads que vão para o then executam e threads 

que vão para o else esperam 

• Passo 2: Threads que vão para o then esperam e threads que 

vão para o else executam 

• Divergências podem causar grande degradação de desempenho


Exemplo: Código divergente 

__global__ void 

ex (float* v) { 

if (v[tid] < 0.0) { 

v[tid] /= 2; 

} else { 

v[tid] = 0.0; 

} 

}


Exemplo: Execução do código divergente


Tese 

A otimização de aplicações de propósito geral em GPUs demanda 

o desenvolvimento de novas técnicas de análises estáticas e 

dinâmicas, bem como a sua integração, em particular para analisar 

e otimizar divergências. 

Contribuições: 

1 Ferramenta para medição (profiling) de divergências 

2 Análise estática para detecção de desvios divergentes 

3 Otimização de código divergente


Medição de Divergências 

• Objetivo: 

• Mensurar, via profiling, o número de visitas e divergências de 

cada desvio durante a execução do programa. 

• Vantagens: 

• Mostra o que aconteceu em detalhes 

• Desvantagens: 

• Resultados dependem da entrada 

• Em geral fornece exemplos, sem provar propriedades 

• Overhead: alguns códigos ficaram 100x mais lentos


Resultados 

1000  

100  

10  

1  

2  

3  

4  4  

5  

1  1  1  1  1  

bp.as  

sc.ud  

mr.ru  

bf.K2  

8  9  10  10  12  13  14  14  14  16  17  17  19  

3  

1  1  

qs.p3  

bf.Kl  

mr.bu  

rn.32  

3  

bp.ld  

tn.ml  

1  

3  

sr.s2  

rn.26  

1  

2  

st.pl  

qs.p2  

4  

3  

5  5  

sc.pn  

nw.n1  

nw.n2  

sd.su  

221  

101  

74  

26  27  32  32  34  

44  47  

2  2  

3  

cf.cx  

tn.sn  

sr.s1  

62  

8  8  9  

34  

21  

11  

14  

qs.p1  

hp.cp  

cs.ui  

dc.cs  

fd.fl  

qs.lt  

Number of Blocks  Number of Branches  Number of Divergent Branches  

hw.kl 


Exemplos de comportamento divergente 

!"#$!%& 

!"#$%*& 

!"#$%)& 

!"#$%(& 

!"#$%'& 

!"#$%%& 

!"#$%+& 

!"#$%*& 

!"#$%)& 

!"#$%(& 

!"#$%'& 

!"#$%!& 

!"#$%%& 

Heartwall (hw.kl) 

!& !!& '!& +!& (!& ,!& )!& -!& *!& .!& !%!& !!!& !'!& !+!& 

!& (& *& ,& -& !!& !(& !*& !,& !-& '!& '(& '*& ',& '-& (!& ((& (*& 

!"#$%-& 

!"#$%,& 

!"#$%+& 

!"#$%*& 

!"#$%)& 

!"#$%(& 

!"#$%'& 

!"#$%!& 

!"#$%%& 

FDTD3d (fd.fl) Dxtc (dc.cs) 

Number of times the branch was visited 

!"#$%-& 

!"#$%,& 

!"#$%+& 

!"#$%*& 

!"#$%)& 

!"#$%(& 

!"#$%'& 

!"#$%!& 

!"#$%%& 

lqsort (qs.Lt) 

!& *& .& !(& !,& '!& '*& '.& ((& (,& )!& )*& ).& *(& *,& 

!& '& (& )& *& +& ,& -& .& !%&!!&!'&!(&!)&!*&!+&!,&!-&!.&'%&'!&''&'(&')&'*& 

Number of divergences


Exemplo: GPU Quicksort 

__global__ static void bitonicSort(int * values) { 

extern __shared__ int shared[]; 

const unsigned int tid = threadIdx.x; 

shared[tid] = values[tid]; 

__syncthreads(); 

for (unsigned int k = 2; k 0; j /= 2) { 

unsigned int ixj = tid ^ j; 

if (ixj > tid) { 

if ((tid & k) == 0) { 7,329,816 / 28,574,321 

if (shared[tid] > shared[ixj]) { 

15,403,445 / 20,490,780 

swap(shared[tid], shared[ixj]); 

} 

} else { 

if (shared[tid] < shared[ixj]) { 

4,651,153 / 8,083,541 

swap(shared[tid], shared[ixj]); 

} 

} 

} 

__syncthreads(); 

} 

} 

values[tid] = shared[tid]; 

}



L 3 

14 

15 

16 

17 

L 5 

L 2 

%t2 = ld %shared[%tid] 

%t3 = ld %shared[%ixj] 

%p3 = gt %t2 %t3 

bra %p3 L7 

st %shared[%tid] %t3 

st %shared[%ixj] %t2 

%t1 = and %tid %k 

%p2 = eq %t1 0 

bra %p2 L3 

sync 

L 1 

7,329,816 / 28,574,321 

L 7 

L 4 

%ixj = xor %tid %j 

%p1 = gt %ixj %tid 

bra %p1 L2 

%t4 = ld %shared[%tid] 

%t5 = ld %shared[%ixj] 

%p4 = lt %t4 %t5 

bra %p4 L7 

15,403,445 / 20,490,780 4,651,153 / 8,083,541 

18 

19 

L 6 

12 

13 

4 

5 

6 

7 

1 

2 

3 

st %shared[%tid] %t5 

st %shared[%ixj] %t4 

8 

9 

10 

11



Primeira Otimização: aceleração de 6,75% 

Segunda Otimização: aceleração de 9,2% 

unsigned int a, b; 

if ((tid & k) == 0){ 

b = tid; 

a = ixj; 

} else { 

b = ixj; 

a = tid; 

} 

if (sh[b] > sh[a]){ 

swap(sh[b],sh[a]); 

} 


%p2 = eq %t1 0 

bra %p2 L3 

%b = mov %tid 

%a = mov %ixj 

%b = mov %ixj 

%a = mov %tid 

%t2 = ld %shared[%b] 

%t3 = ld %shared[%a] 

%p3 = gt %t2 %t3 

bra %p3 L7 

sync 

st %shared[%a] %t3 

st %shared[%b] %t2 

int p = (tid & k) == 0; 

unsigned b = p?tid:ixj; 

unsigned a = p?ixj:tid; 

if (sh[b] > sh[a]) { 

swap(sh[b], sh[a]); 

} 


%p = eq %t1 0 

%a = sel %tid %ixj %p 

%b = sel %ixj %tid %p 

%t2 = ld %shared[%b] 

%t3 = ld %shared[%a] 

%p3 = gt %t2 %t3 

bra %p3 L7 

st %shared[%a] %t3 

st %shared[%b] %t2 

(a) (b) (c) (d) 

sync


Análise estática: Detecção de desvios divergentes 

• Objetivo: verificar se um desvio pode ser divergente ou não, 

sem precisar executar o programa. 

• Todo desvio na GPU é expresso na forma: @pred bra $LABEL 

• @pred: variável booleana (predicado) 

• Podemos verificar se desvio diverge avaliando este predicado 

@pred. 

• Se @pred possuir o mesmo valor para todas as threads, então o 

desvio não pode ser divergente.


Variáveis divergentes 

Definição: Variável divergente 

Uma variável é divergente se threads diferentes a vêem com valores 

diferentes. 

Variáveis não divergentes por definição: 

• Argumentos do kernel 

• Memória da GPU (o valor de um load é divergente só se o 

endereço o for) 

Variáveis divergentes por definição 

• tid: id da thread (usado para divisão de dados entre as 

threads) 

Mas, e as outras variáveis?


Dependências entre variáveis 

• Dependência de dados: 

• uma variável é usada pra calcular a outra 

• c = r ∗ 2 ∗ 3.14; 

• Dependência de controle: 

• uma variável é usada para controlar um desvio que contém a 

atribuição de outra variável: 

if (y > 0) { 

x = 0; 

} else { 

x = 1; 

} 

• É mais fácil encontrar dependências de controle em programas 

que estão em formato SSA (Static Single Assignment): 

if (y > 0) { 

x1 = 0; 

} else { 

x2 = 1; 

} 

x = φ(x1, x2);


Exemplo: Código em SSA


Detecção de variáveis divergentes 

• Dependências de controle: 

• Adiciona predicado que controla desvio à função-φ, 

transformando-as em dependências de dados 

p = (y > 0); 

if (p) { 

x1 = 0; 

} else { 

x2 = 1; 

} 

x = φ(x1, x2); 

p = (y > 0); 

if (p) { 

x1 = 0; 

} else { 

x2 = 1; 

} 

x = φ(x1, x2), p; 

• Prova que desvios com predicados não-divergentes serão 

não-divergentes


Exemplo: SSA modificado


Exemplo: Grafo de dependências 

p 1 

t 0 

j 3 

j 2 

j 0 

j 

j 1 

x 0 

j 4 

p 0 

i 1 

x 

p 2 

i 

i 0 

x 1 

tid


Resultados


Precisão da análise


Análise estática x dinâmica 

• A análise dinâmica (profiler) permite testar a análise estática 

• Obtemos nossa taxa de 34% de falsos positivos na análise 

estática via comparação com profiler 

• A análise estática permite reduzir o overhead do profiler 

• Temos de instrumentar somente 75% dos desvios, pois 

podemos provar que os outros 25% não são divergentes


Otimização: Unificação de blocos básicos 

Estratégia 

• Encontrar trechos de código comum 

• Mover código comum para fora da região divergente 

• Quando instruções usarem operandos diferentes, escolher 

operando adequado via instrução de seleção


Exemplo 

(a) 

l 4 

l 1 

(b) 

load(t 1, tid) 

t 2 = t 1 * t 1 

t 3 = t 2 * t 1 

t 4 = t 3 * 3.14 

t 5 = t 4 / t 0 

t 6 = t 5 / t 0 

t 7 = t 1 * 2.71 

t 8 = t 6 + t 7 

store(t 8, tid) 


p 0 = t 0 ≠ 0.0 

branch(p 0, l 13) 

l 22 

T = 

F = 

l 13 

sync 

stop 

 

 

 

 

 

 


t 10 = t 9 * t 9 

t 11 = t 10 * 3.14 

t 12 = t 11 / 2.00 

t 13 = t 9 * 2.71 

t 14 = t 13 * t 9 

t 15 = t 12 + t 14 

store(t 15, tid) 

jump(l 22) 

 

 

 

(c) 

l 8 

 

 

 

 

l 1 

 

 

t 4 = t 3-11 * 3.14 

t 5 = t 4 / t 0 

l 10 

 

 


p 0 = t 0 ≠ 0.0 

load(t 1-9 , tid) 

t 2-10 = t 1-9 * t 1-9 

s 1 = sel(p 0 , t 2-10 , 3.14) 

t 3-11 = t 2-10 * s 1 

branch(p 0 , l 10 ) 

sync 

s 2 = sel(p 0 , t 5 , t 3-11 ) 

s 3 = sel(p 0 , t 0 , 2.0) 

t 6-12 = s 2 / s 3 

t 7-13 = t 1-9 * 2.71 

branch(p 0, l 16) 

l 16 

sync 

t 8-15 = t 6-12 + t 7-13 

store(t 8-15 , tid) 

l15 t14 = t7-13 * t1-9


Algoritmo 

• Distância de edição 

• Trechos comuns 

• Instruções que só existem em A 

• Instruções que só existem em B 

• Porém distância de edição é muito limitado 

• Instruções diferentes têm custos diferentes 

• Smith-Waterman


Exemplo 

→ 

2 → 

↓ 

0 → 0 → 0 → 0 → 0 → 0 → 0 → 0 

0 100→ 

98 → 98 → 98 → 98 → 98 → 98 → 98 

↓ ↓ 

0 98 102→100 →100→100→100→100→100 ↓ ↓ ↓ 

0 98 100 104→102→102→102→102→ 102 

↓ ↓ ↓ ↓ 

0 98 100 102→102 104→104→104→104 ↓ ↓ ↓ ↓ 

0 98 100 102 110→108→108→108→108 ↓ ↓ ↓ ↓ 

0 

↓ 

98 

↓ 

100 

↓ 

102 

↓ 

110→108→108→108→108 ↓ 

0 

↓ 

98 

↓ 

100 

↓ 

102 

↓ 

108 

↓ 

112→110→110→110 ↓ 

0 98 100 102 108 110 113 112 →110 

↓ ↓ ↓ ↓ ↓ ↓ ↓ ↓ 

0 98 100 102 108 110 111 110 212 

→ → → 

→ 

→ 

→ → → 

0 1 2 3 4 5 6 7 8 

→ 

→ 

0 

1 

2 

3 

4 

5 

6 

7 

8 

9


Resultados


Contribuições: 

Publicações: 

• Artigo Performance Debugging of GPGPU Applications 

with the Divergence Map no International Symposium on 

Computer Architecture and High Performance Computing 

SBAC 2010 

• Premio de melhor artigo da conferência 

• Artigo Profiling divergences in GPU applications 

submetido para a revista Concurrency and Computation: 

Practice and Experience (CCPE) 

• Artigo Divergence Analisys and Optimizations em 

International Conference on Parallel Architecture and 

Compilation Techniques (PACT) 2011 

• Taxa de aceitação de 16% 

Tecnologia: 

• Vários patches do compilador Ocelot foram desenvolvidos.


Conclusões 

• GPUs são dispositivos com grande capacidade computacional 

• Aproveitar todo esse potencial não é trivial 

• Existem poucas ferramentas para ajudar o programador nessa 

tarefa 

• Criamos algumas ferramentas para atender essa demanda 

• Estas ferramentas se complementam 

Trabalhos Futuros: 

• Melhoria da precisão da análise de divergências, acoplando-a 

com a técnica de detecção de valores afins de Colange et al. 

• Alocação de registradores com ciência de variáveis divergentes


Perguntas? 

Dúvidas? Sugestões?

Utilização de técnicas de análise estática e dinâmica para ... - UFMG

Create successful ePaper yourself

Delete template?

Save as template?