Caracterização e análise de benchmarks típicos para execução em GPUS

(1)

DEPARTAMENTO DE CI ÊNCIA DA COMPUTAÇ ÃO

Pablo Moreira Cavalcante de Carvalho

CARACTERIZAC

¸ ˜

AO E AN ´

ALISE DE BENCHMARKS

T´IPICOS PARA EXECUC

¸ ˜

AO EM GPUS

Niter´oi 2017

(2)

CARACTERIZAC

¸ ˜

AO E AN ´

ALISE DE BENCHMARKS

T´IPICOS PARA EXECUC

¸ ˜

AO EM GPUS

Monografia apresentada ao Departamento de Ciência da Computação da Universidade Federal Fluminense como parte dos requisi-tos para obtenção do Grau de Bacharel em Ciência da Computação.

Orientador: Lúcia Maria de Assumpção Drummond Co-orientador: Cristiana Barbosa Bentes

Niter´oi 2017

(3)

Ficha Catalográfica elaborada pela Biblioteca da Escola de Engenharia e Instituto de Computação da UFF

C331 Carvalho, Pablo Moreira Cavalcante de

Caracterização e análise de benchmarks típicos para execução em GPUS / Pablo Moreira Cavalcante de Carvalho. – Niterói, RJ : [s.n.], 2017.

60 f.

Projeto Final (Bacharelado em Ciência da Computação) – Universidade Federal Fluminense, 2017.

Orientadores: Lúcia Maria de Assumpção Drummond, Cristina Barbosa Bentes.

1. Unidade de processamento gráfico. 2. Processamento paralelo (Computador). 3. Computação de alto desempenho. I. Título.

CDD 006.6

(4)

(5)

As minhas orientadoras L´ucia Drummond e Cristiana Bentes, pela oportunidade, comprometimento e

solicitude. Aos meus professores, pela sólida formação que obtive durante a graduação, em especial ao

professor Edson Cataldo pela valorosa contribuição nesse trabalho. À minha fam´ılia, pelo suporte financeiro e motivacional.

(6)

condições pré-concebidas.” Richard P. Feynman

(7)

As unidades de processamento gráfico são hoje uma plataforma importante para a computação de propósito geral, graças ao seu alto desempenho com um baixo custo paralelo. As GPUs, en-tretanto, apresentam arquiteturas significativamente diferentes das CPUs e exigem mapeamen-tos e otimizações espec´ıficas para alcançar alto desempenho. Por este motivo, os conjunmapeamen-tos de benchmarksutilizados para avaliar o desempenho e a escalabilidade da GPU são diferentes dos desenvolvidos para a CPU. Como o uso da GPU para programação paralela de propósito geral é um fenômeno relativamente novo, os conjuntos de benchmarks utilizados para a sua avaliação, também são bastante novos. Atualmente temos os conjuntos Rodinia, Parboil e SHOC como os principais benchmarks para avaliação de GPUs. Este trabalho pretende realizar um estudo de-talhado destes conjuntos de benchmarks de modo a categorizar seu comportamento em termos do tipo principal de computação (inteiro ou ponto-flutuante), do uso da hierarquia de memória e da eficiência obtida pela ocupação do hardware. Pretendemos também avaliar a similaridade de benchmarks de diferentes conjuntos. Esta caracterização será útil para a classificação dos benchmarkse para expor ao usuários como os benchmarks podem ser usados para avaliar de-terminadas caracter´ısticas do sistema.

Palavras Chave:

(8)

Graphical Processing Units are today an important plataform to general purpose computing, thanks to high performance combined with low cost. GPUs, however, present significantly dif-ferent architectures from CPUs and require specific programming and optimizations to reach high performance. Thus, benchmark suites developed to evaluate GPUs performance and sca-lability are different from suites developed for CPUs. Not only the usage of GPUs to genereal purpose parallel programming is relatively new but the suites used for their evaluation are new as well. Nowadays Rodinia, Parboil and SHOC are the main benchmark suites for evaluating GPUs. This work analyses those benchmark suites in detail and categorize their behaviors in terms of main type of computation (integer or float), usage of memory hierarchy and efficiency obtained by hardware occupancy. We intend also to evaluate similarities between those suites. The characterization will be useful to classify and show GPU users how benchmarks can be applied to evaluate systems characteristics.

Keywords:

(9)

GPU: Graphics Processing Unit CPU: Central Processing Unit SM: Stream Multiprocessor MPI: Message Passing Interface PCA: Principal Component Analysis MPS: Multi-Processor Service

(10)

CAPÍTULO 1 - INTRODUÇ ÃO 6

CAP´ITULO 2 - CONCEITOS B ´ASICOS 9

2.1 Principal Component Analysis -PCA . . . 9

2.1.1 C´alculo das componentes . . . 9

2.1.2 Exemplo . . . 10

2.1.3 Utilizando PCA na Linguagem R . . . 14

2.2 K-means . . . 19

CAP´ITULO 3 - PACOTES DE BENCHMARKS 22 3.1 Rodinia . . . 22

3.2 Parboil . . . 24

3.3 Scalable Heterogeneous Computing (SHOC) benchmark suite . . . 25

CAP´ITULO 4 - METODOLOGIA 27 4.1 Ferramentas e ambiente utilizado . . . 27

4.2 Aquisic¸˜ao e tratamento dos dados . . . 28

CAP´ITULO 5 - AN ´ALISE DE RESULTADOS 31 5.1 Rodinia . . . 31

5.1.1 Grupo 1 - Kernels com uso de mem´oria intensiva . . . 33

5.1.2 Grupo 2 - Kernels de pouca express˜ao . . . 34

5.1.3 Grupo 3 - Kernels com alto número de operações de ponto flutuante de precisão dupla . . . 35

(11)

5.2 Parboil . . . 37

5.2.1 Grupo 1 - Kernels com alta eficiˆencia . . . 39

5.2.2 Grupo 2 - Kernels com alta eficiˆencia e baixa ocupˆancia . . . 39

5.2.3 Grupo 3 - Kernels de execução rápida com uso intensivo de inteiros . . 40

5.2.4 Grupo 4 - Kernels de execução rápida e baixo uso de registradores . . . 40

5.2.5 Grupo 5 - Kernels pouco significativos . . . 41

5.3 SHOC . . . 41

5.3.1 Grupo 1 - Kernels com maior tempo de execução e uso de memória . . 43

5.3.2 Grupo 2 - kernels pouco significantes . . . 44

5.3.3 Grupo 3 - kernels de execução rápida e baixa ocupância . . . 46

5.4 An´alise com todos os kernels . . . 47

5.4.1 Grupo 1 - Kernels pouco significativos . . . 49

5.4.2 Grupo 2 - Kernels robustos . . . 49

5.4.3 Grupo 3 - Kernels de comportamento neutro . . . 50

5.4.4 Grupo 4 - Kernels de baixa ocupˆancia e alta eficiˆencia . . . 51

CAP´ITULO 6 - CONCLUS ˜AO 52

(12)

Figura 1: Gr´afico exemplo . . . 11

Figura 2: Transformac¸˜ao usando apenas um autovetor . . . 13

Figura 3: Transformac¸˜ao usando dois autovetores . . . 14

Figura 4: Scatter plot . . . 15

Figura 5: variˆancias . . . 16

Figura 6: biplot . . . 17

Figura 7: biplot com classificac¸˜ao . . . 18

Figura 8: exemplo, adaptado de [13] . . . 20

Figura 9: movimentac¸˜ao dos centroides, adaptado de [13] . . . 20

Figura 10: algoritmo k-means, adaptado de [26] . . . 21

Figura 11: gr´afico exibindo duas componentes . . . 32

Figura 12: gr´afico exibindo trˆes componentes . . . 32

Figura 13: gr´afico rotacionado exibindo trˆes componentes . . . 33

Figura 14: Parboil: gr´afico com duas componentes . . . 38

Figura 15: SHOC: gr´afico com duas componentes . . . 42

Figura 16: kernels de todos os pacotes, gr´afico com duas componentes . . . 48

Figura 17: grupo 1, n´umero de kernels por pacote . . . 49

(13)

1 dados de exemplo . . . 11

2 dados centrados na m´edia . . . 12

3 GTX 980: especificação . . . 27 4 Descrição de métricas . . . 29 5 Rodinia, grupo 1 . . . 34 6 Rodinia, grupo 2 . . . 35 7 Rodinia, grupo 3 . . . 35 8 Rodinia, grupo 4 . . . 36 9 Parboil, grupo 1 . . . 39 10 Parboil, grupo 2 . . . 39 11 Parboil, grupo 3 . . . 40 12 Parboil, grupo 4 . . . 40 13 Parboil, grupo 5 . . . 41

14 SHOC, grupo 1, parte 1 . . . 43

15 SHOC, grupo 2 . . . 44

16 SHOC, grupo 3, parte 1 . . . 45

(14)

CAP´ITULO 1 - INTRODUC

¸ ˜

AO

As Unidades de Processamento Gráfico (GPU) têm obtido grande destaque nos dias de hoje na computação de propósito geral. A razão custo/desempenho dessas unidades aliada ao seu alto poder computacional vem conquistando cada vez mais usuários. Por esta razão os principais fabricantes de GPUs têm se preocupado em modificar a arquitetura, drivers e pacotes de desenvolvimento para que suas unidades combinem a facilidade de desenvolvimento e alto desempenho em aplicações de propósito geral. Atualmente os computadores mais rápidos do mundo segundo o site Top 500 [24] são constru´ıdos utilizando clusters heterogêneos CPU-GPU. Devido à crescente capacidade das GPUs atuais é comum que as aplicações não utilizem todo o potencial computacional dispon´ıvel. Além disso, GPUs têm sido utilizadas de forma compartilhada em ambientes de nuvem. Em GPUs modernas é poss´ıvel que uma GPU execute kernelsde diferentes processos, ou contextos, ao mesmo tempo. No entanto fica a cargo do usuário compreender as necessidades das aplicações que deseja executar e as limitações da GPU utilizada, para assim julgar se existe algum ganho em executá-las de forma concorrente.

Alguns pacotes de benchmarks foram criados ao longo dos anos com intuito de avaliar o desempenho de GPUs em uma série de aplicações reais. São eles, Rodinia [22, 23], Parboil [10] e SHOC [3]. Estes benchmarks têm sido utilizados para avaliar aspectos de arquitetura e pa-ralelismo oferecidos pelas GPUs com o foco em determinar experimentalmente os benef´ıcios de novos projetos. Seu uso, entretanto, tem sido restrito a avaliações das execuções de cada aplicação isoladamente. Quando diferentes aplicações são executadas na mesma GPU de modo concorrente, as caracter´ısticas de cada aplicação em termos de tipo de computação, uso de memória e tempo de execução, determinam a interferência que elas vão gerar no desempenho umas das outras.

Diante deste cenário, é preciso compreender melhor o comportamento de cada aplicação destes benchmarks em termos de uso dos recursos da GPU para que o usuários possam en-tender melhor sobre a diversidade destas aplicações e sobre como elas se comportam quando executados concorrentemente na GPU. Além disso, diferentemente dos benchmarks propostos para CPUs, os benchmarks para GPU são compostos de uma série de kernels. Cada kernel representa uma tarefas submetida para execução maciçamente paralela na GPU e pode possuir necessidades diferentes de uso de recursos durante sua execução.

(15)

Esse trabalho tem por objetivo apresentar uma análise do comportamento de kernels dos três principais benchmarks desenvolvidos para GPUs através da observação de métricas corres-pondentes a operações com inteiros e ponto flutuante de precisão simples e dupla, eficiência, ocupação e as caracter´ısticas de operações em memória. Pela dificuldade em representar visual-mente os kernels em um espaço que possui número de dimensões igual ao número de métricas utilizadas no estudo, recorremos a técnica Principal Component analysis para reduzir a dimen-sionalidade e assim conseguirmos representar toda a informação em gráficos de espaços de duas e três dimensões sem ignorar nenhuma métrica. Para determinarmos os grupos utilizamos o k-means a partir da sa´ıda gerada pelo PCA.

Trabalhos de caracterização de aplicações de pacotes de bbenchmarks já foram realizados para os pacotes PARSEC [4] e também para o pacote Rodinia [23], ambos usando analise das principais componentes, no entanto a diferença desse trabalho para os trabalhos citados é o seu objeto de análise, enquanto os trabalhos observavam as aplicações, esse trabalho analisa cada kernelde cada aplicação e faz uma analise sobre seu comportamento. Outros trabalhos como Kerr et al. [2], analisa aplicações do pacote Parboil e das aplicações de exemplo do CUDA SDK em termos de controle de fluxo, fluxo de dados, paralelismo e comportamento de memória. No entanto o estudo não foi feito utilizando uma GPU real, e sim um simulador.

Burtscher et al. [15] realizou o estudo de 13 benchmarks irregulares em termos de irre-gularidade de controle de fluxo e irreirre-gularidade de acesso a memória, é feita também uma comparação com aplicações do CUDA SDK. Em um trabalho posterior O’Neil e Burtscher [17] apresentam a caracterização de cinco aplicações irregulares do pacote LonestarGPU, o estudo é baseado em simulações e também é focado no impacto no controle de fluxo e irregularidade no acesso a memória. Bakhoda et al. [1] caracteriza 12 kernels em um simulador de GPU, o estudo é baseado em algumas escolhas de projeto de microarquiteturas: interconexão de topo-logia, uso de cache, design do controlador de memória, mecanismos paralelos de distribuição de workloads e requisições de memória.

Devido ao estado atual das arquiteturas das GPUs, que a partir da arquitetura Kepler da NVIDIA permite que uma aplicação execute kernels concorrentemente e ainda o MPS que per-mite que kernels de mais de uma aplicação sejam executadas em uma mesma GPU concorren-temente [19], esse estudo traz resultados que podem ser usados para compreender uma poss´ıvel interferência desses kernels quando utilizando esses recursos recentes.

Nos resultados encontrados, foi poss´ıvel identificar grupos de kernels que utilizam pouco os recursos analisados, assim como grupos que utilizavam muito diversos tipos de recursos. Também chegamos a conclusão de que Rodinia e Parboil, apesar não terem sido atualizados

(16)

tão recentemente quanto o SHOC, possuem aplicações que fazem maior uso da GPU, en-quanto o SHOC com kernels mais simples, se destaca pelo uso de concorrência em uma de suas aplicações.

Este projeto está organizado em 6 cap´ıtulos, No Cap´ıtulo 2, apresentamos os métodos uti-lizados no trabalho para a análise das informações extra´ıdas dos kernels das aplicações. No cap´ıtulo 3, descrevemos cada pacote de benchmark assim como descrevemos brevemente cada uma de suas aplicações. No cap´ıtulo 4, descrevemos a metodologia de extração de dados e o ambiente utilizado para os testes. No cap´ıtulo 5, realizamos uma analise dos dados extra´ıdos. No cap´ıtulo 6 mostramos nossas conclusões sobre os dados obtidos.

(17)

CAP´ITULO 2 - CONCEITOS B ´

ASICOS

Neste capitulo apresentamos a teoria das t´ecnicas de an´alise de dados usadas para compre-ender o comportamento dos kernels.

2.1 PRINCIPAL COMPONENT ANALYSIS -PCA

O PCA é uma técnica de análise multivariada, consiste em realizar uma transformação linear com um conjunto de dados de modo que este mesmo conjunto seja representado a par-tir de suas componentes mais importantes [9]. As componentes do PCA são nada mais que combinações lineares dos eixos do espaço que representa o conjunto de dados, dessa forma o PCA pode informar quais são os eixos onde se encontram as maiores variâncias e assim pode-mos definir quais seriam as mais importantes e que melhor caracterizam um conjunto de dados, descartando assim as menos importantes, por essa razão o método é comumente utilizado para redução de dimensões.

2.1.1 C ´ALCULO DAS COMPONENTES

Dada uma tabela de dados com um numero qualquer de linhas e colunas, organizamos uma matriz do tipo: S=        s2₁ s₁₂ s₁₃ . . . s1n s21 s2₂ s23 . . . s2n .. . ... ... . .. ... s_n1 s_n2 s_n3 . . . s2_n       

A diagonal principal é dada pelo quadrado da variância de cada coluna da tabela de dados, Lé o número de linhas da tabela de dados e ¯xé a média dos valores da coluna:

s2_n= L

∑

i=1 (xin− ¯x)2 L− 1

(18)

As outras posições da matriz são fornecidas pela covariância entre pares de colunas da tabela de dados:

s_{i j}= L ∑ xikxjk− ∑ xik∑ xjk L(L − 1)

Uma vez com a matriz formada, encontraremos seus autovalores e autovetores a partir da equac¸˜ao caracter´ıstica:

|S − λ I| = 0 Dessa forma, teremos uma matriz do tipo:

|S − λ I| =        s2₁− λ s12 s13 . . . s1n s₂₁ s2₂− λ s23 . . . s2n .. . ... ... . .. ... sn1 sn2 sn3 . . . s2n− λ       

Encontrando o determinante dessa matriz encontraremos uma equação que resolvida for-nece todos os autovalores. Para encontrarmos um autovetor substitu´ımos λ por um dos auto-valores encontrados e montamos um sistema de equações homogêneas que resolvido fornecerá um autovetor. Para encontrar todos os autovetores é necessário repetir o processo para cada autovalor.

Conhecendo todos os autovetores montamos uma matriz de transformação onde cada auto-vetor será uma coluna da matriz. Podemos utilizar todos os autoauto-vetores encontrados no entanto isso não é interessante para um caso onde queremos reduzir o número de dimensões de um problema. O critério de escolha é montar a matriz com autovetores gerados pelos maiores au-tovalores, o que significa escolher as componentes onde se encontram as maiores variâncias e por sua vez diferenciam melhor os dados um dos outros.

Com a matriz de transformação criada o último passo é obter as coordenadas do conjunto de dados original transformadas no novo sistema de coordenadas. Para isso basta que criemos uma matriz com os dados do conjunto original e façamos o produto dela com a matriz de transformação.

2.1.2 EXEMPLO

(19)

x y 2.5 2.4 0.5 0.7 2.2 2.9 1.9 2.2 3.1 3.0 2.3 2.7 2 1.6 1 1.1 1.5 1.6 1.1 0.9

Tabela 1: dados de exemplo

Figura 1: Gr´afico exemplo

O PCA pode indicar uma variância muito maior em uma coluna devido a diferença de escalas com as variáveis envolvidas, o que em muitos casos não é desejável, por isso algumas vezes é necessário padronizar os dados. A padronização consiste em subtrair cada item de uma coluna pela média e dividir o resultado pelo desvio padrão, para o exemplo dado não

(20)

há necessidade de dividir pelo desvio padrão já que as colunas usam a mesma escala, assim subtra´ımos apenas a média, o resultado será:

x y 0.69 0.49 -1.31 -1.21 0.39 0.99 0.9 0.29 1.29 1.09 0.49 0.79 0.19 -0.31 -0.81 -0.81 -0.31 -0.31 -0.71 -1.01

Tabela 2: dados centrados na m´edia

Com os dados padronizados, podemos calcular a matriz de transformac¸˜ao:

S= "

0.6165556 0.6154444 0.6154444 0.7165556 #

Para encontrar os autovalores basta resolver o determinante da matriz:

|S − λ I| = " 0.6165556 − λ 0.6154444 0.6154444 0.7165556 − λ # = 0

Os valores de λ encontrados foram λ1= 0.490833989 e λ2= 1.28402771. Substituindo λ na matriz por 0.490833989 e depois por 1.28402771 e resolvendo os sistemas de equaç ões homogêneas, encontraremos os autovetores:

A= "

−0.677873399 −0.735178656 −0.735178696 0.677873399

#

com o intuito de reduzir dimens˜oes vamos utilizar apenas um autovetor, e faremos o produto com os dados padronizados em uma matriz, o resultado desse produto ser´a uma matriz coluna contendo as coordenadas :

(21)

                       0.69 0.49 −1.31 −1.21 0.39 0.99 0.9 0.29 1.29 1.09 0.49 0.79 0.19 −0.31 −0.81 −0.81 −0.31 −0.31 −0.71 −1.01                        " −0.677873399 −0.735178696 # =                        −0.827970186 1.77758033 −0.992197494 −0.274210416 −1.67580142 −0.912949103 0.0991094375 1.14457216 0.438046137 1.22382056                       

(22)

                       0.69 0.49 −1.31 −1.21 0.39 0.99 0.9 0.29 1.29 1.09 0.49 0.79 0.19 −0.31 −0.81 −0.81 −0.31 −0.31 −0.71 −1.01                        " −0.677873399 −0.735178656 −0.735178696 0.677873399 # =                        −0.827970186 −0.175115307 1.77758033 0.142857227 −0.992197494 0.384374989 −0.274210416 0.130417207 −1.67580142 −0.209498461 −0.912949103 0.175282444 0.0991094375 −0.349824698 1.14457216 0.0464172582 0.438046137 0.0177646297 1.22382056 −0.162675287                       

Assim, cada linha da matriz seria uma coordenada transformada para o novo espac¸o.

Figura 3: Transformac¸˜ao usando dois autovetores

2.1.3 UTILIZANDO PCA NA LINGUAGEM R

Utilizaremos como exemplo o conjunto de dados Iris [20], trata-se de um conjunto com 50 amostras de cada um dos trˆes tipo de flores do gˆenero Iris, totalizando assim 150 amostras. O

(23)

conjunto Iris já está inclu´ıdo nos pacotes do R, assim, para carregá-lo basta usar o comando: d a t a ( i r i s )

O conjunto de dados é composto de 5 colunas, sendo elas Sepal.Length, Sepal.Width, Pe-tal.Lenght, Petal.Width e Species, sendo os quatro primeiros as medidas que nos interessam e Species a classificação de cada flor. Por enquanto vamos separar os dados da classificação para uso posterior:

d a t a s e t <− i r i s [ , 1 : 4 ]

Podemos visualizar os dados através do scatter plot, uma representação de todos os pares de eixos do conjunto de dados através do comando

p l o t ( d a t a s e t , c o l = i r i s $ S p e c i e s )

Passamos no segundo parâmetro a classificação presente no conjunto assim teremos uma representação por cores da classificação de cada flor, o resultado será:

Figura 4: Scatter plot

Através dessa representação é poss´ıvel notar que alguns pares de eixos diferenciam melhor esses conjuntos. Utilizando o PCA poderemos confirmar quais desses realmente diferenciam

(24)

e ter maior noção de em quais se concentram a maior variância. Assim, utilizamos a função princomp passando como parâmetro o conjunto de dados:

i r i s . p c a <− p r i n c o m p ( d a t a s e t )

Não há necessidade de centrar os dados na média antes de usar a função devido ao modo como a função calcula as componentes. Nesse conjunto de dados também não existe a neces-sidade de corrigir o problema das escalas pois o conjunto de dados usa a mesma escala, caso existisse a necessidade, bastaria usar a função scale da seguinte forma :

d a t a s e t <− s c a l e ( d a t a s e t , s c a l e = TRUE , c e n t e r = TRUE )

A linguagem R possui também em seus pacotes a função prcomp para cálculo das principais componentes, a diferença entre princomp e prcomp está na forma como as componentes são calculadas. Enquanto princomp utiliza autovetores e autovalores para calcular as componentes [6], técnica mostrada na seção anterior, prcomp utiliza decomposição em valores singulares [7] devido a maior precisão numérica.

A partir do resultado do PCA, precisamos analis´a-lo e definir quais componentes possuem maior peso, dessa forma podemos visualizar graficamente o resultado:

p l o t ( i r i s . p c a )

O resultado será um gráfico com a variância de cada componente:

(25)

Pelo gráfico podemos observar que boa parte do peso se encontra na primeira componente, então para montarmos uma representação gráfica certamente essa componente estará inclu´ıda, incluiremos também a segunda componente. Para representar graficamente o PCA com duas dimensões utilizaremos o biplot [8], dessa forma além dos pontos transformados para o novo sistema de coordenadas, também teremos inclu´ıdos os vetores com os pesos de cada eixo do sistema anteriormente utilizado. A implementação de biplot utilizada não faz parte dos pacotes padrão do R, a biblioteca utilizada chama-se ggbiplot:

g <− g g b i p l o t : : g g b i p l o t ( i r i s . pca , c h o i c e s = c ( 1 , 2 ) , o b s . s c a l e = 1 , v a t . s c a l e = 1 , e l l i p s e = TRUE , c i r c l e = TRUE )

p l o t ( g )

A sa´ıda ser´a um gr´afico do tipo:

Figura 6: biplot

´

E poss´ıvel observar um grupo se formando mais isolado, a esquerda do c´ırculo, já no caso do . A sa´ıda do PCA pode ser utilizada como entrada para um algoritmo de classificação, no caso o conjunto já possui uma classificação, então, para visualizá-la apenas inclu´ımos mais um parâmetro na função ggbiplot, sendo um vetor contendo a classificação de cada ponto:

(26)

v a t . s c a l e = 1 , e l l i p s e = TRUE , c i r c l e = TRUE , g r o u p s = i r i s $ S p e c i e s )

p l o t ( g )

Figura 7: biplot com classificac¸˜ao

O gráfico gerado pelo biplot fornece algumas informações interessantes principalmente quando combinado ao resultado de algum algoritmo de agrupamento, o resultado ajuda a com-preender quais são as caracter´ısticas mais marcantes de um grupo. Para isso, deve-se ter atenção ao tamanho dos vetores, a sua direção, as posições dos grupos e a variância das componentes. Em relação ao tamanho, ele indica a importância daquela caracter´ıstica para os elementos em geral, a sua direção e sentido indicam a relação de importância para um grupo. Observar os dados originais é fundamental, pois quando temos vários vetores apontando para um grupo e vários em sentido contrário é poss´ıvel que alguns desses não caracterizem o grupo. A variância de uma componente pode informar muito sobre a importância de uma caracter´ıstica, uma carac-ter´ıstica paralela a uma componente de alta variância dependendo do tamanho do módulo pode indicar que a caracter´ıstica tem uma alta variância para o conjunto de dados e é altamente im-portante, assim como uma caracter´ıstica paralela a uma componente de variância muito baixa tem pouca importância. Pode haver casos onde uma parte do grupo tem valores muito altos para uma caracter´ıstica e outra parte do grupo valores muito altos para outra, tendo assim duas

(27)

caracter´ısticas que unem o grupo mas que n˜ao necessariamente tem valores muito altos para todos os elementos, ou mesmo muito baixos.

Na Figura, observamos que as espécies versicolor e virginica apesar de possu´ırem alguns pontos afastados, em sua maioria as caracter´ısticas Petal.Width e Petal.Lenght aparentam ter um peso maior para esses grupos, a espécie virginica pelo que se observa é o que tem essas carac-ter´ısticas com maior peso, em segundo a espécie versicolor, esses dados se confirmam quando observamos o conjunto de dados. Também pela observação das mesmas caracter´ısticas, perce-bemos que o grupo setosa é o que possui os menores valores para Petal.Width e Petal.Lenght. Com relação as outras caracter´ısticas, Sepal.Length tem um peso alto para as espécies versi-color e virginica enquanto é baixo para a espécie setosa. Quanto a Sepal.Width, o tamanho do vetor e a direção mais próxima a PC2, componente com peso muito baixo, indica que essa caracter´ıstica não possui grande variância em relação as outras e por isso não é tão eficaz em diferenciar os grupos.

2.2 K-MEANS

K-means é um método de agrupamento que consiste em encontrar grupos em meio a dados não classificados. A classificação consiste na escolha aleatória de posições para um número n de centroides passados como parâmetro para o método, a cada iteração calcula-se a distância eucli-diana de um centroide a cada ponto, os dados, e identifica um grupo de pontos mais próximos a ele do que ao centro de qualquer outro grupo, o segundo passo é calcular a média de cada carac-ter´ıstica para os pontos do grupo em questão, essa média será a nova posição do centroide. Os dois passos serão repetidos até que haja convergência. [25] Como exemplo, temos um conjunto de dados representado em um gráfico de duas dimensões exibido na figura 8, ao aplicarmos o k-means nos dados temos a sa´ıda representada na figura 9, a figura demonstra também a movimentação dos centroides a cada iteração partindo do ponto inicial ao ponto final.

(28)

Figura 8: exemplo, adaptado de [13]

(29)

(30)

CAP´ITULO 3 - PACOTES DE BENCHMARKS

Benchmarks são programas desenvolvidos com intuito de analisar sistemas computacio-nais, com o estudo da execução desses programas através de métricas bem definidas é poss´ıvel aprender sobre o funcionamento de uma arquitetura espec´ıfica, identificar gargalos na execução de programas e comparar a diferença entre arquiteturas diferentes [4]. Em situações onde se deseja testar o comportamento de um programa espec´ıfico que está implementado apenas em uma arquitetura, é interessante que se utilize um benchmark com caracter´ısticas mais próximas o poss´ıvel do programa em questão, assim se evitariam custos para implementar o código em outras arquiteturas [5]. Em qualquer caso de uso de um benchmark é fundamental que tais pro-gramas estejam preparados para colocar em teste todos os recursos do hardware no qual serão executados.

Diferente dos benchmarks popularmente associados a GPUs como 3DMark, o intuito deste trabalho é avaliar os benchmarks desenvolvidos para computação de propósito geral, sem neces-sariamente estarem associados a tarefas que envolvem computação gráfica, mas que tenham as respectivas implementações para GPUs. Os benchmarks analisados, Rodinia, Parboil e SHOC possuem implementações para diversos tipos de hardware, no entanto nosso objetivo é estudar seu comportamento em GPUs especificamente.

3.1 RODINIA

O Pacote de benchmarks Rodinia disponibilizado em 2009, hoje encontra-se em sua versão 3.1, tem por foco a análise de sistemas heterogêneos e possui implementações em CUDA, OpenCL e OpenMP. O pacote, composto inicialmente de 8 aplicações, hoje possui vinte e três aplicações nas quais a escolha foi inspirada na taxonomia de anões de Berkley [11]

• Leukocyte - A partir de um v´ıdeo capturado por meio de um microscópio, a aplicação detecta as células em um primeiro frame e após isso acompanha seu movimento.

• Heart Wall - Faz a reconstrução aproximada das paredes do coração de um rato à partir da detecção dos movimentos do coração em uma sequência de imagens de ultrassom.

(31)

• MUMmerGPU - Aplicação de alinhamento de sequências de DNA.

• CFD Solver - Aplicação de dinâmica de fluidos que consiste em resolver equações de Euler em três dimensões.

• LU Decomposition - Implementação de algoritmo para calcular soluções de equações lineares.

• HotSpot - Resolve equac¸˜oes diferenciais para estimar a temperatura de um processador com base na planta e medidas de consumo de energia.

• Back Propagation - Implementação do algoritmo de aprendizado de máquina.

• Needleman-Wunsch - Um método de otimização global não linear para alinhamento de sequências de DNA.

• Kmeans - Aplicação que implementa o algoritmo de agrupamento. • Breadth-First Search - Implementação do clássico algoritmo de busca.

• SRAD - Aplicação para remoção de ru´ıdos conhecidos como speckles de aplicações de imagens de ultrassom e radar.

• Streamcluster - Implementação originalmente do pacote de benchmarks Parsec. É basi-camente um método de agrupamento.

• Particle Filter - Aplicação de filtro de part´ıculas, um estimador estat´ıstico para busca de um objeto, otimizado para encontrar células.

• PathFinder - Aplicac¸˜ao para encontrar o caminho mais curto entre dois pontos.

• Gaussian Elimination - Resolve um sistema de equações lineares pelo método de eliminação de Gauss.

• k-Nearest Neighbors - Método de agrupamento que utiliza a distância euclidiana entre pontos para agrupá-los.

• LavaMD2 - Aplicação para cálculo de interação de part´ıculas. • Myocyte - Aplicação de modelagem de células card´ıacas. • B+ Tree - Implementação de busca em árvores B+.

(32)

• Hybrid Sort - Algoritmo de ordenac¸˜ao que usa bucketsort ou quicksort para dividir uma lista em sublistas a serem ordenadas em paralelo usando merge-sort.

• Hotspot3D - sem informações. • Huffman - sem informações.

3.2 PARBOIL

O pacote Parboil foi desenvolvido em 2008 para testar e demonstrar a capacidade da pri-meira geração de GPUs com a tecnologia CUDA. Segundo o conceito de seu desenvolvimento, a composição do pacote foi pensada para não entregar versões completamente otimizadas em baixo n´ıvel para um determinado dispositivo e nem versões completas de aplicações que aca-bem por desencorajar modificações[10]. Atualmente o Parboil é composto de 11 aplicações de diversas áreas:

• Breadth-First Search (BFS) - Implementac¸˜ao de busca em largura.

• Distance-Cutoff Coulombic Potential (CUTCP) - Utilizada para modelagem molecular, essa aplicação computa uma pequena faixa de componentes em um mapa de campo ele-trostático produzido por átomos distribu´ıdos em um volume.

• Saturating Histogram (HISTO) - Conta o n´umero de ocorrˆencias de certos valores em uma base de dados.

• Boltzmann Method Fluid Dynamics (LBM) - Implementação do método de Lattice-Boltzmann para solução de equações diferenciais parciais orientadas a dinâmica de flui-dos.

• Magnteic Resonance Imaging Gridding ( MRI-GRIDDING ) - Aplicação do método grid-dingde reconstrução de imagens para ressonância magnética.

• Magnetic Resonance Imaging Q (MRI-Q) - Usado em algoritmos reconstrução de ima-gens de ressonância magnética, computa uma matriz Q que representa a configuração dos dados de calibragem de um scanner.

• Sum of Absolute Differences (SAD) - Algoritmo usado em compress˜ao de v´ıdeos para estimar movimento comparando blocos de um quadro em outro quadro de referˆencia afim de encontrar o bloco mais similar.

(33)

• Dense Matrix-Matrix Multiply (SGEMM) - Aplicação que realiza a operação de multiplicação entre matrizes com ponto flutuante de precisão simples.

• Sparse-Matrix Dense-Vector Multiplication (SPVM) - Multiplicação otimizada para ma-trizes onde a maior parte dos elementos é zero.

• 3-D Stencil Operation (STENCIL) - Aplicação que resolve uma equação de calor em um gridestruturado 3D utilizando o método iterativo de Jacobi.

• Two Point Angular Correlation Function (TPACF) - A aplicação faz uma medida de distribuição de corpos massivos no espaço, a sa´ıda é um histograma de distâncias an-gulares entre todos os pares de objetos observados.

3.3 SCALABLE HETEROGENEOUS COMPUTING (SHOC) BENCHMARK

SUITE

Concebido para GPUs e processadores com vários núcleos, o pacote de benchmarks SHOC implementa paralelismo para o caso da utilização de mais de uma GPU utilizando MPI. O SHOC está organizado em três n´ıveis, o primeiro sendo o n´ıvel zero, composto de aplicações que medem caracter´ısticas de hardware em baixo n´ıvel. O n´ıvel 0 utiliza kernels artificiais e foi projetado para ter consistência a fim de que além de um teste de performance, também tenha outros usos como detectar problemas no hardware. O n´ıvel um implementa algoritmos que realizam tarefas frequentemente encontradas em aplicações paralelas reais como o Fast Fourrier Transform[3]. O n´ıvel dois é composto de aplicações reais de fato [21].

• N´ıvel zero:

– BusSpeedDownload e BusSpeedReadback: medem a largura de banda do barra-mento PCI-express conectando o hospedeiro e o dispositivo para transferir dados de tamanho vari´avel.

– Device Memory: Mede a largura de banda para todos os espaços de endereçamento incluindo memória global, local, constante e de imagem.

– Kernel Compilation: Aplicação para medir tempo de compilação de um kernel. – MaxFlops : Executa kernels sintéticos para atingir o numero máximo de operações

de ponto flutuante poss´ıvel com o hardware utilizado.

(34)

• N´ıvel um:

– BFS: Implementac¸˜ao de busca em largura.

– FFT: Implementac¸˜ao do algoritmo Fast Fourrier Transform.

– MD: Aplicação de dinâmica molecular, computa a aceleração de uma particula ba-seada no campo potêncial gearado por todas as particulas em uma área determinada. – Reduction: Aplicação que implementa o algoritmo de redução de soma

– Scan : Implementac¸˜ao do algoritmo de soma cumulativa.

– GEMM : Aplicação que faz multiplicação de matrizes utilizando BLAS.

– Sort : Implementação de algoritmo radix sort onde a chave do par é um número inteiro.

– Spmv : Multiplicação otimizada para matrizes onde a maior parte dos elementos é zero.

– Stencil2D : Implementação do Stencil para um espaço 2D com nove pontos. – Triad : Implementação do produto escalar para vetores.

• N´ıvel dois:

– S3D : Aplicação que calcula taxa de reações qu´ımicas.

– QTC : Implementação de método de agrupamento similar ao k-means que não ne-cessita de ter como entrada o número de grupos desejado.

(35)

CAP´ITULO 4 - METODOLOGIA

Este cap´ıtulo apresenta a metodologia empregada para analisar os kernels dos pacotes de benchmarks

4.1 FERRAMENTAS E AMBIENTE UTILIZADO

Para os testes foi utilizada uma GTX 980 com a especificac¸˜ao a seguir [18] [14]

CUDA Cores 2048

Base Clock 1126 MHz

GPU Boost Clock 1216 MHz

GFLOPs 4612

Compute Capability 5.2

SMs 16

Shared Memory / SM 96KB Register File Size / SM 256KB Active Blocks / SM 32

Texture Units 128

Texel fill-rate 144.1 Gigatexels/s

Memory 4096MB

Memory Clock 7010 MHz

Memory Bandwidth 224.3 GB/sec

ROPs 64 L2 Cache Size 2048KB TDP 165 Watts Transistors 5.2 billion Die Size 398 mm2 Manufacturing Process 28 nm Tabela 3: GTX 980: especificac¸˜ao

(36)

GPUs modernas da NVIDIA, O computador utilizado utilizava o sistema operacional Ubuntu na versão 14.04. Para compilar e executar os benchmarks utilizamos a versão 7.5 do CUDA. Quanto a utilização dos métodos de análise, utilizamos a linguagem R com os seguintes pacotes :

• primcomp - pacote para calculo das principais componentes usando autovetores e auto-valores.

• prcomp - pacote para calculo das principais componentes usando decomposição vetorial. • rgl - pacote para plotar gráficos 3D.

• ggbiplot - pacote que implementa biplots.

4.2 AQUISIC

¸ ˜

AO E TRATAMENTO DOS DADOS

A priori, dado um pacote de benchmarks, todas as aplicações foram executadas e extra´ımos as métricas utilizando o nvprof, ferramenta disponibilizada pela NVIDIA para medir o desem-penho das aplicações. Na execução foram utilizados dois modos para adquirir os dados, gpu-trace e metrics, onde cada modo era utilizado em execuções separadas. As métricas extra´ıdas no modo metrics estão descritas na tabela 4.

Algumas métricas usadas fazem referência a warps e para entendê-los é necessário antes conhecer o conceito de blocos e algumas outras abstrações que envolve o desenvolvimento vol-tado a GPUs e sua arquitetura. Kernels são o equivalente a funções de um programa normal, no entanto serão executados pela GPU. A execução de um kernel possui uma abstração que se chama thread. Um bloco é uma abstração para um conjunto de threads, o número de threads em um bloco pode variar mas existe um limite estabelecido para cada arquitetura. Cada bloco é executado em um SM (stream multiprocessor), dessa forma todas as threads de um bloco são executadas no mesmo SM, no entanto um SM não executa um bloco de uma só vez, os SM executam conjuntos de 32 threads chamadas warps e como exibido na Tabela 3, existe um número máximo de warps que podem ser executados em um mesmo SM. Existem critérios para execução simultânea de warps no mesmo SM associados a uso de recursos e dependência de dados, assim pode acontecer de warps associados a um SM ficarem esperando por um determi-nado recurso, portanto não estariam ativos. [16]

(37)

Métrica Descrição

sm efficiency porcentagem de tempo em que pelo menos um warp esta ativo em um multiprocessador em relac¸˜ao a todos os multi-processadores da GPU

achieved occupancy taxa de warps ativos em um SM em relação ao número máximo de warps ativos suportados pelo SM

shared load transactions contagem de operações de leitura na memória comparti-lhada

shared store transactions contagem de operações de escrita na memória comparti-lhada

local store transactions contagem de operações de escrita na memória local local load transactions contagem de operações de leitura na memória local gld transactions contagem de operações de leitura na memória global gst transactions contagem de operações de escrita na memória global inst fp 32 operações de ponto flutuante de precisão simples realizadas inst fp 64 operações de ponto flutuante de precisão dupla realizadas inst integer operações com inteiros realizadas

Tabela 4: Descrição de métricas

O nvprof retorna valores máximos, médios e m´ınimos para cada métrica apresentada, utili-zamos apenas os valores médios de cada métrica. A partir dos dados extra´ıdos, somamos

sha-red load transactionse shared store transactions, chamamos o resultado de shared total transactions, a soma entre local load transactions e local store transactions foi nomeada local total transactions, do mesmo modo a soma entre gld transactions e gsd transactions foi chamada de global total -transactions. Uma vez com os dados das métricas foi necessário organizar as sa´ıdas do nvprof em uma tabela onde cada kernel foi identificado por uma letra correspondente a aplicação da qual fazia parte junto a um número que o diferenciava dos kernels da mesma aplicação.

Devido a variação nas grandezas das métricas, algumas eram porcentagens enquanto outras tratavam-se de contagem de eventos que algumas vezes chegavam a milhões, foi necessário centrar e normalizar os dados uma vez que essa diferença entre as métricas influenciaria os resultados do PCA. Outro ponto é que algumas métricas precisaram ser exclu´ıdas da análise nos casos onde os valores medidos para todos os kernels eram zero, já que tal fato impossibilitaria o uso do PCA.

(38)

Nas primeiras análises utilizando o PCA junto a observação dos dados, era vis´ıvel que haviam kernels de pouca importância para a nossa análise e que acabavam por influenciar o resultado do PCA. Assim definimos um critério para remover os kernels pouco importantes para as aplicações, o critério trata-se do seguinte, dado uma aplicação e o conjunto de kernels que a compõe, utilizamos o tempo médio de execução de cada kernel e calculamos a porcentagem do tempo de execução do kernel em relação ao tempo de execução da aplicação. Dados de tempo de execução dos kernels, número de execuções e número de registradores, também inclu´ıdo na tabela de entrada para o PCA, foram extra´ıdos usando o modo gpu-trace do nvprof. Caso um kerneltivesse a porcentagem do tempo de execução menor do que o tempo médio de execução dos outros kernels da mesma aplicação subtra´ıdo do desvio padrão, o kernel era cortado da analise. Assim, após o corte dos kernels de baixa importância, o PCA era executado novamente. Após o tratamento dos dados, observamos o peso das componentes dado pelo PCA, assim, de acordo com um gráfico que exibia a variância de cada componente. Conforme a variação do peso das componentes, decidimos se utilizar´ıamos duas ou três dimensões.

Com os dados do PCA, utilizamos o k-means para determinar os grupos. O número de grupos foi obtido experimentalmente e com variações para cada pacote de benchmark. Assim, a partir das diferentes sa´ıdas que obtivemos de cada pacote analisamos como as métricas se comportavam para um dado grupo, quando haviam grupos onde as métricas se comportavam de maneira muito semelhante,nós utilizávamos o k-means com um número menor de grupos até que tivéssemos um número de grupos onde cada grupo tivesse métricas que variavam de forma semelhante dentro do grupo e de forma distinta em relação aos outros grupos.

Obtidos os dados do K-means junto aos do PCA, analisamos cada grupo gerado em termos das métricas e categorizamos esses grupos a partir de suas caracter´ısticas. Também observamos o comportamento de cada aplicação e a poss´ıvel presença dos kernels em grupos de carac-ter´ısticas diferentes.

(39)

CAP´ITULO 5 - AN ´

ALISE DE RESULTADOS

Neste cap´ıtulo apresentamos os resultados dos experimentos realizados com os pacotes de benchmarks e interpretações para esses resultados. Nas análises dos grupos encontrados em cada pacote, para que fosse poss´ıvel distinguir os kernels nos gráficos sem comprometer a visi-bilidade, usamos uma codificação que consiste em um par formado por uma letra e um número, assim cada kernel ganhou um código composto por uma letra que corresponde a aplicação na qual pertence e um número para distingui-lo dos outros kernels da mesma aplicação. Devido a criação da codificação foi necessário apresentamos tabelas, algumas muito extensas, associando esses códigos às aplicações e aos kernels.

5.1 RODINIA

Começamos com cinquenta e oito kernels de vinte e duas aplicações, assim detectamos kernelsde pouca expressão que consumiam poucos recursos e eram executados em um tempo muito baixo. Esses kernels pouco expressivos dificultavam a análise visual e assim utilizamos o critério descrito no cap´ıtulo 4 para removê-los. Após a remoção dos kernels, ficamos com um total de quarenta e quatro, nenhuma aplicação teve todos os seus kernels cortados.

Tivemos problemas para extração de métricas da aplicação CFD e por isso tivemos que retirá-la da análise. Também removemos para esse caso a métrica de contagem para operações na memória local devido ao baixo uso por parte de todos os kernels da aplicação, o que tornava a métrica pouco importante para observação das variâncias.

Talvez pela época em que foram desenvolvidas, com exceção da aplicação Huffman in-clu´ıda na versão 3.0 de 2015, as aplicações do pacote Rodinia não fazem uso de paralelismo no que se refere a criação de mais de uma stream, o que faz com que kernels da mesma aplicação possam ser executados de forma concorrente. Talvez exista a possibilidade de otimização de algumas aplicações do pacote ao usarem essa tecnologia, no entanto isso traria a necessidade de reimplementação de alguns algoritmos.

Nesse caso utilizamos três componentes do PCA como entrada para o k-means devido a distribuição das variâncias mas representamos esse resultado tanto em um gráfico tridimensional

(40)

quanto um gr´afico bidimensional.

Figura 11: gr´afico exibindo duas componentes

(41)

Figura 13: gr´afico rotacionado exibindo trˆes componentes

A direção dos vetores nos gráficos nos fornece algumas informações interessantes no caso do Rodinia, a maioria dos kernels observados que fazem transações na memória global também fazem transações na memória compartilhada, indicando que a maior parte das transações de memória acontecem entre esses dois tipos. Outro caso é a associação de ocupância, número de instruções com inteiros e eficiência.

5.1.1 GRUPO 1 - KERNELS COM USO DE MEM ´ORIA INTENSIVA Grupo composto pelos kernels a seguir:

(42)

código aplicação kernel

B1 backprop bpnn layerforward CUDA

D1 dwt2d fdwt97Kernel

D4 dwt2d c CopySrcToComponents I1 huffman vlc encode kernel sm64huff

J4 hybridsort bucketsort

J7 hybridsort bucketcount

N2 lud lud perimeter

N3 lud lud internal

R1 nw needle cuda shared 1

R2 nw needle cuda shared 2

U1 pathfinder dynproc kernel

W2 srad-v1 reduce

Tabela 5: Rodinia, grupo 1

Pelo posicionamento do grupo nos gráficos, observamos a tendência do mesmo para realização de operações em memória sendo essa sua caracter´ıstica mais marcante. No entanto há outras caracter´ısticas interessantes quando observamos o gráfico com três componentes e os dados originais, o grupo não faz operações com ponto flutuante de precisão dupla, tem ocupância variável enquanto sua eficiência é alta para a grande maioria dos integrantes, boa parte também faz operações com inteiros.

O grupo possui alguns elementos mais afastados da maioria, caso de R1 e R2 devido a sua baixa ocupância, próxima de 6%, o que significa que durante a execução desses kernels, haviam poucos warps ativos em relação a capacidade máxima do SM. O kernel J4 também tem caracter´ıstica similar adicionada ao fato de que não faz operações com inteiros.

5.1.2 GRUPO 2 - KERNELS DE POUCA EXPRESS ˜AO O grupo ´e identificado pelos kernels a seguir:

(43)

E2 gaussian Fan1

N1 lud lud diagonal

P1 myocyte 10 kernel

S2 particlefilter-float likelihood kernel S3 particlefilter-float normalize weights kernel

Apesar do critério de corte descrito nesse trabalho, alguns poucos kernels passaram pelo critério e acabaram por integrar esse grupo. Através da observação dos dados junto a representação visual chegamos a conclusão de que o grupo tem pouca relevância em termos de uso de recur-sos, assim como seu tempo de execução é ´ınfimo quando comparado aos kernels das aplicações das quais fazem parte. Um ponto importante a ser levantado é a aplicação myocite só estar pre-sente nesse grupo, demonstrando que para os critérios que observamos a aplicação tem pouca relevância.

5.1.3 GRUPO 3 - KERNELS COM ALTO N ÚMERO DE OPERAÇ ÕES DE PONTO FLU-TUANTE DE PRECIS ÃO DUPLA

código aplicação kernel F1 heartwall kernel H1 hotspot calculate temp L1 lavaMD kernel gpu cuda M2 leukocyte IMGVF kernel X1 srad-v2 srad cuda 1 X2 srad-v2 srad cuda 2

Esse grupo é caracterizado por operações com ponto flutuante de precisão dupla, essa carac-ter´ıstica o diferencia dos demais grupos ainda que também realize um alto número de operações de ponto flutuante de precisão simples. Observando as assinaturas dos kernels dessas aplicações só encontramos variáveis do tipo double no kernel da aplicação lavaMD, o que se confirma em seu código fonte. Quanto as outras aplicações, assim como suas assinaturas sugerem, o código fonte dos kernels não faz uso de variáveis do tipo double, o que parece contrariar os resultados

(44)

mostrados pelo nvprof para a métrica em questão, isso também pode ser observado em casos isolados nos outros grupos.

5.1.4 GRUPO 4 - ALTA OCUP ÂNCIA E OPERAÇ ÕES COM INTEIROS

A1 b+tree findRangeK

A2 b+tree findK

B2 backprop bpnn adjust weights cuda

C1 bfs Kernel

C2 bfs Kernel2

E1 gaussian Fan2

G1 hotspot3d hotspotOpt1

J5 hybridsort mergeSortPass

K1 kmeans invert mapping

K2 kmeans kmeansPoint

O1 mummergpu mummergpuKernel

O2 mummergpu printKernel

Q1 nn euclid

S4 particlefilter-float find index kernel T1 particlefilter-naive kernel

V1 sc gpu kernel compute cost

W3 srad-v1 srad2

W5 srad-v1 prepare

W6 srad-v1 srad

O grupo mais populoso dos quatro, a posição dos integrantes do grupo oposta aos vetores de operação em memória nos dá a informação que se confirma nos dados originais de que os kernels desse grupo não realizam operações na memória compartilhada e nem na memória global. Sua posição é também justificada pela proximidade dos vetores de ocupância, eficiência, operações com inteiros e a porcentagem do tempo de execução dos kernels, apesar desse grupo de vetores caracterizarem o grupo, isso não necessariamente significa que todos os integrantes tem valores altos para todas essas caracter´ısticas, mas que para a maioria delas isso se confirma.

(45)

5.2 PARBOIL

Para essa análise, retiramos a contagem de operações com variáveis de ponto flutuante de precisão dupla em razão dos kernels não realizarem esse tipo de operação segundo os dados do nvprof, logo não havia variância. Outro corte realizado foi em relação aos kernels, dos vinte e seis originais ao utilizarmos o critério de corte ficamos com vinte e quatro. Os kernels cortados pertenciam as aplicações MRI-Q e SAD, não eram os únicos kernels dessas aplicações, assim não foram completamente descartadas.

De todos os pacotes analisados, o Parboil é o mais antigo, não existem aplicações nele que façam uso de várias streams, assim, não possui uso de concorrência em uma mesma aplicação. Quanto ao uso do PCA, as duas primeiras componentes possuem mais de 50% da variância, assim nesse caso optamos pela abordagem com duas dimensões. O baixo número de kernels com relação aos outros pacotes também dificultou a analise com k-means, assim utilizamos a sa´ıda do método apenas como um ponto de partida e modificamos o agrupamento inicial através da comparação entre os elementos dos grupos.

(46)

Figura 14: Parboil: gr´afico com duas componentes

A direção dos vetores no gráfico indicam a associação entre o número de transações com a memória compartilhada e o total de operações com números de ponto flutuante, assim como a correlação desse par com o número de registradores utilizados pelos kernels em uma execução. Também nota-se a relação entre transações na memória global e a eficiência dos SMs.

(47)

5.2.1 GRUPO 1 - KERNELS COM ALTA EFICI ˆENCIA

B1 cutcp cuda cutoff potential lattice6overlap

D1 lbm performStreamCollide kernel

E2 mri-gridding splitRearrange

E8 mri-gridding splitSort

F1 mri-q ComputeQ GPU

G2 sad mb sad calc

G3 sad larger sad calc 8

I1 spmv spmv jds

E7 mri-gridding gridding GPU

H1 sgemm mysgemmNT

Tabela 9: Parboil, grupo 1

São os Kernels mais representativos do Parboil, sua caracter´ıstica principal é a alta eficiência, o que indica baixa ociosidade por parte dos SMs. A posição dos seus elementos no gráfico aponta que o grupo é uma combinação de kernels que fazem operações com memória com-partilhada ou global, ou ainda os dois tipos simultaneamente. O kernel E7 esta visivelmente mais afastado do grupo, isso deve-se ao número de operações com inteiros que faz, na ordem de bilhões, seu número de transações na memória compartilhada também é bem alto, o kernel apenas se sobressai mas segue as caracter´ısticas do grupo.

5.2.2 GRUPO 2 - KERNELS COM ALTA EFICI ˆENCIA E BAIXA OCUP ˆANCIA

A1 bfs BFS kernel multi blk inGPU J1 stencil block2D hybrid coarsen x

Os Kernels desse grupo são únicos para suas respectivas aplicações, uma das caracter´ısticas que definem a posição do grupo no gráfico, no entanto o que os torna uma exceção em relação aos kernels de outros grupos é a forma como os SMs são utilizados, a alta eficiência se deve ao fato dos warps estarem sendo utilizados na maior parte do tempo, a baixa ocupância indica que os SMs não estão sendo pouco utilizados. Especificamente esse caso indica que sempre há

(48)

warpsnos SMs, por outro lado h´a um n´umero bem mais baixo de warps do que a capacidade total dos SMs.

5.2.3 GRUPO 3 - KERNELS DE EXECUÇ ÃO R ÁPIDA COM USO INTENSIVO DE IN-TEIROS

C1 histo histo prescan kernel

C2 histo histo main kernel

C3 histo histo final kernel

C4 histo histo intermediates kernel E9 mri-gridding scan L1 kernel

G1 sad larger sad calc 16

A posição desse grupo, com o vetor correspondente a métrica de porcentagem do tempo apontando em direção oposta, indica que os integrantes tem baixa porcentagem de tempo quando comparados aos kernels das aplicações das quais fazem parte. Outra de suas caracter´ısticas são as operações com números inteiros, a contagem não é tão elevada quanto o primeiro grupo, no entanto é alta se comparada com os outros. Também é vis´ıvel que a posição dos integrantes desse grupo se opõem ao vetor de instruções com ponto flutuante de precisão simples, o pouco uso dessas instruções é algo recorrente para praticamente todos os integrantes. Quanto as outras métricas o grupo se comporta de maneira irregular, o que de fato contribuiu para sua posição mais centralizada.

5.2.4 GRUPO 4 - KERNELS DE EXECUÇ ÃO R ÁPIDA E BAIXO USO DE REGISTRA-DORES

código aplicação kernel E1 mri-gridding reorder kernel E4 mri-gridding uniformAdd E6 mri-gridding binning kernel

O grupo composto apenas de Kernels da aplicação mri-gridding, sua posição é explicada pela sua baixa porcentagem de tempo, uso de baixo número de registradores, caracter´ıstica

(49)

crucial para diferenciá-lo dos demais grupos. Observa-se também uma grande quantidade de operações com inteiros e operações na memória global. Eficiência e ocupância são médias para E4, o que explica o fato de estar um pouco mais afastado de E1 e E6.

5.2.5 GRUPO 5 - KERNELS POUCO SIGNIFICATIVOS

código aplicação assinatura do kernel

A2 bfs BFS in GPU kernel

K1 tpacf gen hists

O grupo é constitu´ıdo basicamente de kernels que passaram no critério de corte mas tem usam pouco os recursos analisados em relação aos que constituem as outras aplicações do pa-cote.

5.3 SHOC

Dos pacotes analisados, o SHOC, é o que recebeu atualizações mais recentemente, muito provavelmente por esse motivo encontramos aplicações que fazem uso massivo de múltiplas streams, sendo elas S3D e Triad, assim existe concorrência entre kernels diferentes sendo exe-cutados simultaneamente. Uma caracter´ıstica da implementação das aplicações do SHOC, que o diferencia dos demais pacotes, é ter kernels bem rápidos, e que são executados muitas vezes, aplicações compostas de apenas um kernel são raras.

Quanto a análise realizada, não foi poss´ıvel extrair métricas para algumas aplicações do chamado n´ıvel zero do SHOC, portanto decidimos cortar esse n´ıvel da análise, a proposta desse n´ıvel também teve peso considerável nesse corte por se tratar de um conjunto de aplicações com kernels artificiais para testar nuances de baixo n´ıvel do hardware assim como a detecção de defeitos. Restaram um total de cento e seis kernels onde quarenta e sete pertenciam ao n´ıvel um e cinquenta e nove kernels do n´ıvel dois. Não foi utilizado o critério de corte apresentado no cap´ıtulo 4, primeiro pelo grande número de kernels do pacote, segundo por que a maior parte da diversidade do pacote encontra-se nos kernels que seriam hipoteticamente cortados, já que são integrantes do n´ıvel um desse pacote.

(50)

Figura 15: SHOC: gr´afico com duas componentes

Para o gráfico escolhemos utilizar duas componentes, devido as duas primeiras componen-tes deterem mais de 60% da variância. O gráfico mostra uma forte correlação entre a porcen-tagem de tempo e o número de operações na memória compartilhada, enquanto as operações em memória global estão associadas à eficiência. Também há uma certa proximidade entre as operações com números inteiros e as de ponto flutuante de precisão simples. De resto, as métricas estão bem distribu´ıdas.

(51)

5.3.1 GRUPO 1 - KERNELS COM MAIOR TEMPO DE EXECUÇ ÃO E USO DE MEM ÓRIA

D3 FFT FFT512 device

D4 FFT IFFT512 device

D5 FFT IFFT512 device

D6 FFT FFT512 device

E1 GEMM maxwell sgemm 128x64 nn

E2 GEMM gemm kernel2x2 tile multiple core

E3 GEMM maxwell sgemm 128x64 nt

E4 GEMM void gemm kernel2x2 tile multiple core

F1 MD5Hash FindKeyWithDigest Kernel

G1 MD compute lj force

H3 NeuralNet axpy kernel val

H7 NeuralNet kernelBackprop1

H8 NeuralNet gemm kernel1x1 core

I1 Reduction reduce

I2 Reduction reduce

J1 Scan reduce

J2 Scan reduce

J3 Scan bottom scan

J6 Scan bottom scan

K2 Sort findRadixOffsets

K3 Sort radixSortBlocks

K5 Sort reorderData

L1 Spmv void spmv csr vector kernel

L7 Spmv void spmv csr vector kernel

M1 Stencil2D void StencilKernel

M2 Stencil2D void StencilKernel

N1 Triad triad

O1 QtClustering QTC device

Tabela 14: SHOC, grupo 1, parte 1

O grupo é composto praticamente todo de aplicações do n´ıvel um, o que faz com que seja o grupo mais diverso. Entre suas caracter´ısticas estão, a porcentagem de tempo alta em relação

(52)

aos outros grupos, alto número de operações nas memórias global e compartilhada, ocupância média. As operações mais realizadas pelo grupo são as com números inteiros.

5.3.2 GRUPO 2 - KERNELS POUCO SIGNIFICANTES

C1 BFS BFS kernel warp H1 NeuralNet kernelFeedForward3 H2 NeuralNet kernelBackprop3b H4 NeuralNet kernelBackprop3a H5 NeuralNet kernelInitNablaB H6 NeuralNet kernelBackprop2

H9 NeuralNet kernelInitNablaW(float*, int)

J4 Scan scan single block

J5 Scan void scan single block

K1 Sort scan K4 Sort vectorAddUniform4 L2 Spmv zero L3 Spmv zero L4 Spmv spmv ellpackr kernel L5 Spmv spmv csr scalar kernel L6 Spmv spmv ellpackr kernel L8 Spmv spmv csr scalar kernel

O2 QtClustering reduce card device O4 QtClustering trim ungrouped pnts indr array O5 QtClustering update clustered pnts mask

Tabela 15: SHOC, grupo 2

A posição do grupo afastada nos gráficos e oposta ao sentido dos vetores das métricas indica que esse grupo é pouco significante, usa pouco os recursos analisados. Apresenta ape-nas uma porcentagem de tempo bem diversa entre seus elementos, o que contribuiu para essa representação.

(53)

D1 FFT chk512 device

D2 FFT chk512 device

G2 MD compute lj force

O3 QtClustering compute degrees

P1 s3d rdsmh kernel P2 s3d rdwdot10 kernel P3 s3d qssab kernel P4 s3d ratt kernel P5 s3d rdwdot2 kernel P6 s3d rdwdot3 kernel P7 s3d rdwdot6 kernel P8 s3d rdwdot7 kernel P9 s3d rdwdot8 kernel P10 s3d rdwdot9 kernel P11 s3d qssa2 kernel P12 s3d ratx2 kernel P13 s3d rdwdot kernel P14 s3d ratx4 kernel J1 Scan reduce J2 Scan reduce

J3 Scan bottom scan

J6 Scan bottom scan

K2 Sort findRadixOffsets K3 Sort radixSortBlocks K5 Sort reorderData L1 Spmv spmv csr vector kernel L7 Spmv spmv csr vector kernel M1 Stencil2D StencilKernel M2 Stencil2D StencilKernel N1 Triad triad O1 QtClustering QTC device Tabela 16: SHOC, grupo 3, parte 1

(54)

5.3.3 GRUPO 3 - KERNELS DE EXECUÇ ÃO R ÁPIDA E BAIXA OCUP ÂNCIA P15 s3d ratt10 kernel P25 s3d ratt9 kernel P26 s3d qssa kernel P27 s3d rdsmh kernel P28 s3d rdwdot10 kernel P29 s3d qssab kernel P30 s3d ratt kernel P31 s3d rdwdot2 kernel P32 s3d rdwdot3 kernel P33 s3d rdwdot6 kernel P34 s3d rdwdot7 kernel P35 s3d rdwdot8 kernel P36 s3d rdwdot9 kernel P37 s3d qssa2 kernel P38 s3d ratx2 kernel P39 s3d rdwdot kernel P40 s3d ratx4 kernel P41 s3d ratxb kernel P42 s3d ratxb kernel P43 s3d ratt2 kernel P44 s3d ratt10 kernel P45 s3d ratt3 kernel P46 s3d ratx kernel P47 s3d ratt4 kernel P48 s3d ratt5 kernel P49 s3d ratt6 kernel P50 s3d ratx kernel P51 s3d ratt7 kernel P52 s3d ratt8 kernel P53 s3d ratt9 kernel P54 s3d qssa kernel Tabela 17: SHOC, grupo 3, parte 2

(55)

Grupo composto basicamente por Kernels da aplicação s3d. Especificamente no caso dos kernelsdo s3d, observamos uma baixa porcentagem de tempo e baixa ocupância, uma carac-ter´ıstica das aplicações que utilizam concorrência, kernels rápidos cujo os warps não consomem todo o SM, dando assim espaço para que warps de outros kernels sejam executados. A alta eficiência e o não uso da memória compartilhada também são caracter´ısticas do grupo. Mais uma observação entre as aplicações do s3d, é que mesmo entre elas vemos dois grupos se for-mando, e isso se deve ao fato de que um subgrupo realiza um número alto de operações com números de ponto flutuante de precisão dupla, enquanto o outro subgrupo não faz nenhuma operação desse tipo. No caso de D1 e D2, eles seguem a mesma caracter´ıstica geral do grupo mas tem eficiência bem menor que os outros kernels, por isso sua posição separada dos demais.

5.4 AN ´

ALISE COM TODOS OS KERNELS

Nesta análise unimos todos os kernels dos pacotes estudados, reunimos um total de cento e setenta e três kernels que foram divididos em quatro grupos, utilizamos as duas primeiras componentes, PC1 e PC2, para visualização assim como para entrada do k-means. A motivação para essa analise é mostrar a semelhanças e diferenças entre as aplicações dos pacotes de bench-marks. Por se tratar dessa vez de uma comparação entre pacotes, decidimos por não explicitar os kernels que integram cada grupo, no entanto apresentaremos o número de kernels de cada pacote nos grupos encontrados.

(56)

Figura 16: kernels de todos os pacotes, gr´afico com duas componentes

Comparando a direção dos vetores das métricas desse gráfico com o gráfico do SHOC, é percept´ıvel que devido ao seu grande número de kernels, esse pacote acabou por influen-ciar a posição de alguns vetores como a porcentagem de tempo de execução e a contagem de instruções de ponto flutuante de precisão dupla, o angulo entre esses vetores é praticamente o mesmo. Algumas correlações entre métricas feitas para o SHOC com a presença de kernels mais diversos também diminuiu.

(57)

5.4.1 GRUPO 1 - KERNELS POUCO SIGNIFICATIVOS

Rodinia Parboil SHOC

0 5 10 15 20 n ´umero de k ernels

Figura 17: grupo 1, n ´umero de kernels por pacote

O grupo é uma combinação dos grupos de kernels de baixa importância, usam pouco os recursos analisados, encontrados nas análises individuais dos pacotes. A maior presença de kernelsdo pacote SHOC é resultado do critério de corte utilizado nos outros pacotes, com os quatorze kernels cortados do Rodinia somados aos elementos desse grupo, haveria um empate com o SHOC, Parboil teve poucos kernels cortados, apenas dois, então não influenciaria no resultado.

5.4.2 GRUPO 2 - KERNELS ROBUSTOS

0 5 10 n ´umero de k ernels

O grupo é formado por kernels que possuem alta eficiência, fazem muitas operações com números inteiros e com números de ponto flutuante de precisão simples, tem ocupância média

(58)

por volta de 70%. De todos os grupos analisados, é o que mais utiliza os recursos da GPU. As proporções de kernels por pacote nesse grupo junto as informações do grupo 1, mostram que Rodinia e Parboil possuem kernels que exploram mais a capacidade da GPU do que o pacote SHOC, ainda que esse tipo de kernel não seja maioria para Rodinia e Parboil.

5.4.3 GRUPO 3 - KERNELS DE COMPORTAMENTO NEUTRO

0 5 10 15 20 25 n ´umero de k ernels

O grupo tem caracter´ısticas similares ao grupo dois, alto número de operações com inteiros, ocupância média por volta de 60%. Em termos de porcentagem de tempo também fica atrás do grupo dois mas a frente de todos os outros. A eficiência é alta mas não tanto quanto os grupos dois e quatro. Excluindo o número de operações com ponto flutuante de precisão dupla, operação que em geral o grupo faz muito pouco, o resto das métricas se distribui sem gerar números que superem o grupo dois e nem qualquer caracter´ıstica forte de outro grupo, assim esse grupo se caracteriza mais pelo equil´ıbrio de seus kernels. Vale observar que entre todos, é o grupo mais equilibrado tratando-se do número de kernels que representa cada pacote.

(59)

5.4.4 GRUPO 4 - KERNELS DE BAIXA OCUP ˆANCIA E ALTA EFICI ˆENCIA

0 20 40 60 n ´umero de k ernels

Grupo composto de sessenta e nove kernels, caracterizados pela alta ocupância, baixa eficiência e baixa porcentagem do tempo de execução, o que se justifica por sua composição ser majoritariamente de kernels da aplicação s3d do pacote SHOC, a aplicação tem caracter´ısticas bem distintas das aplicações de todos os outros pacotes e inclusive do próprio pacote a qual per-tence, cinquenta e quatro kernels dessa aplicação fazem parte desse grupo. Outra caracter´ıstica é o número de operações com inteiros mais baixo que os outros grupos, mesmo assim todos os elementos desse grupo fazem esse tipo de operação. Não há kernels do Parboil nesse grupo, além disso há apenas três do pacote Rodinia. De todos os grupos é o que tem a maior média de uso de registradores.