B.4 Modelo roofline para a GPU Tesla K40
5.6 Resultados experimentais com o método CRS
Nesta seção, são apresentados os resultados de desempenho para os programas CRS- OpenMP e CRS-OpenCL que são descritos a seguir:
• CRS-OpenCL : Implementação do método CRS usando OpenCL. Esse mesmo có- digo pode ser executado tanto em CPUs comuns como em aceleradores como GPUs e o Xeon Phi.
• CRS-OpenMP : Implementação do método CRS usando OpenMP. Essa implemen- tação só é executada em CPUs.
A Tabela 5.14 apresenta as características dos dados que são utilizados nos experi- mentos. Os dados são os mesmos usados no método CMP e são apresentados da mesma maneira que os dados para o método CMP na Tabela 5.4.
Nome das entradas CDPs Espaço de Traços Amostras Tamanho Semblance- busca por CDP por traço da janela Traces
Jequitinhonha 201 75 29,5 1701 3 2,16 × 1010
Simple-synthetic 428 75 14,01 2502 3 1,68 × 1010
Micro-synthetic 201 75 15 700 1 3,34 × 106
Tabela 5.14: Descrição de entradas usadas nos experimentos com o CRS.
A Figura 5.16 apresenta os resultados dos experimentos de desempenho utilizando o dado de entrada Simple-synthetic. Observe o desempenho da implementação OpenCL: quando executada em aceleradores é muito maior em relação OpenMP. Outra conclusão
que se pode tirar do gráfico é que, mesmo quando a implementação OpenCL é executada em uma CPU, ela é superior à implementação OpenMP. Isso ocorre para as duas CPUs E5-2630 e E5-2670. A diferença de desempenho nas CPUs é explicada pela ausência de instruções vetoriais no código gerado pelo compilador para à implementação CRS- OpenMP. Mais à frente descreveremos os experimentos que foram realizados para se chegar a essa conclusão.
Figura 5.16: Resultados experimentais para o CRS usando o Simple-synthetic como dado de entrada, descrito na tabela 5.14.
Nas tabelas 5.15, 5.16 e 5.17 são mostrados os ganhos de desempenho entre todas as plataformas para cada dado de entrada. Essas tabelas são construídas da seguinte forma: Para uma linha A e uma coluna B, a tabela contém o ganho de desempenho do dispositivo A em relação ao B dado pela divisão do tempo médio de execução do dispositivo B pelo tempo médio de execução do dispositivo A.
R9 Titan K40 K20 770 Xeon Phi 2670-CL 2630-CL 2670-MP 2630-MP R9 1,00 2,07 2,21 2,63 2,73 7,22 8,47 16,89 40,05 55,83 Titan 0,48 1,00 1,07 1,27 1,32 3,49 4,10 8,17 19,38 27,01 K40 0,45 0,94 1,00 1,19 1,24 3,27 3,83 7,64 18,12 25,26 K20 0,38 0,79 0,84 1,00 1,04 2,74 3,22 6,42 15,22 21,22 770 0,36 0,76 0,81 0,96 1,00 2,64 3,10 6,17 14,63 20,40 Xeon Phi 0,14 0,29 0,31 0,36 0,38 1,00 1,17 2,33 5,53 7,71 2670-CL 0,12 0,24 0,26 0,31 0,32 0,85 1,00 1,99 4,73 6,59 2630-CL 0,06 0,12 0,13 0,16 0,16 0,43 0,50 1,00 2,37 3,31 2670-MP 0,02 0,05 0,06 0,07 0,07 0,18 0,21 0,42 1,00 1,39 2630-MP 0,02 0,04 0,04 0,05 0,05 0,13 0,15 0,30 0,72 1,00
Tabela 5.15: Ganho de desempenho entre os diferentes dispositivos, para o dado de entrada Simple-synthetic.
A implementação CRS-OpenCL se mostra muito mais eficiente do que a CRS-OpenMP para todos os casos apresentados na Figura 5.16. O experimento em que a CRS-OpenCL tem o menor ganho é quando as duas implementações são executadas na CPU E5-2630, onde o ganho de desempenho da CRS-OpenCL é de apenas 3 vezes. Pode-se ver o ver- dadeiro potencial da implementação CRS-OpenCL nos experimentos que utilizam acele- radores como os experimentos com as GPUs GTX-770, GTX-Titan e R9-290x, onde o ganho de desempenho em relação a CRS-OpenMP varia de 17 a 55 vezes, como mostra a tabela 5.15.
O gráfico da Figura 5.17 representa os resultados dos experimentos de desempenho das duas implementações do CRS usando o Jequitinhonha como dado de entrada, ocorre o mesmo com o dado de entrada Simple-Synthetic. O desempenho é muito maior para implementação OpenCL quando ela é executada em algum acelerador em relação à im- plementação em OpenMP usando CPUs multicores.
Mesmo quando as duas implementações estão sendo executadas usando os mesmos processadores multicores, o desempenho da implementação OpenCL é superior. Isso ocorre tanto para a CPU E5-2630 quanto para a CPU E5-2670. As diferenças de desempenho nas CPUs ocorrem por causa do compilador que gera o código da implementação CRS- OpenMP sem instruções vetoriais.
O ganho de desempenho da implementação CRS-OpenCL se mostra grande nas GPUs GTX-770, GTX-Titan e R9-290x, onde o programa atinge tempos de execução que variam de 21 a 62 vezes mais rápido em relação à implementação CRS-OpenMP.
Figura 5.17: Resultados experimentais para o CRS usando o Jequitinhonha como dado de entrada, descrito na tabela 5.14.
R9 Titan K40 K20 770 Xeon Phi 2670-CL 2630-CL 2670-MP 2630-MP
R9 1,00 1,81 2,15 2,66 2,88 7,64 8,82 18,59 45,68 62,44 Titan 0,55 1,00 1,18 1,47 1,59 4,21 4,86 10,24 25,17 34,41 K40 0,47 0,85 1,00 1,24 1,34 3,56 4,11 8,66 21,28 29,09 K20 0,38 0,68 0,81 1,00 1,08 2,88 3,32 6,99 17,18 23,49 770 0,35 0,63 0,75 0,92 1,00 2,66 3,06 6,46 15,87 21,69 Xeon Phi 0,13 0,24 0,28 0,35 0,38 1,00 1,15 2,44 5,98 8,18 2670-CL 0,11 0,21 0,24 0,30 0,33 0,87 1,00 2,11 5,17 7,07 2630-CL 0,05 0,10 0,12 0,14 0,15 0,41 0,47 1,00 2,46 3,36 2670-MP 0,02 0,04 0,05 0,06 0,06 0,17 0,19 0,41 1,00 1,37 2630-MP 0,02 0,03 0,03 0,04 0,05 0,12 0,14 0,30 0,73 1,00
Tabela 5.16: Ganho de desempenho entre os diferentes dispositivos, para o dado de entrada Jequitinhonha.
A Figura 5.18 mostra que para a Micro-synthetic ainda é mais vantajoso usar o código OpenCL, mesmo em CPUs, em vez do OpenMP, já que para as duas CPUs testadas o desempenho da implementação OpenCL foi melhor. Essa diferença ocorre por causa das instruções vetoriais ausentes no código gerado pelo compilador para a implementação CMP-OpenMP. Mais à frente vamos mostrar os experimentos realizados para se chegar a essa conclusão.
Figura 5.18: Resultados experimentais para o CRS usando o Micro-synthetic como dado de entrada, descrito na Tabela 5.14.
R9 Titan K40 K20 770 2670-CL Xeon Phi 2630-CL 2670-MP 2630-MP
R9 1,00 2,00 2,14 2,43 2,73 7,99 8,21 16,60 30,14 58,29 Titan 0,50 1,00 1,07 1,21 1,36 3,99 4,11 8,30 15,07 29,14 K40 0,47 0,93 1,00 1,13 1,27 3,73 3,83 7,75 14,07 27,20 K20 0,41 0,82 0,88 1,00 1,12 3,29 3,38 6,84 12,41 24,00 770 0,37 0,73 0,79 0,89 1,00 2,93 3,01 6,08 11,05 21,36 2670-CL 0,13 0,25 0,27 0,30 0,34 1,00 1,03 2,08 3,77 7,29 Xeon Phi 0,12 0,24 0,26 0,29 0,33 0,96 0,99 2,00 3,64 7,03 2630-CL 0,06 0,12 0,13 0,15 0,16 0,48 0,50 1,00 1,82 3,52 2670-MP 0,03 0,07 0,07 0,08 0,09 0,26 0,27 0,55 1,00 1,93 2630-MP 0,02 0,03 0,04 0,04 0,05 0,14 0,14 0,28 0,52 1,00
Tabela 5.17: Ganho de desempenho entre os diferentes dispositivos, para o dado de entrada Micro-synthetic.
Os resultados dos experimentos para a implementação CRS-OpenCL, usando as GPUs GTX-770, GTX-Titan e R9-290x, mostram grandes ganhos de desempenho em relação à implementação CRS-OpenMP usando as CPUs multicore disponíveis (utilizando como dado de entrada o dado Micro-synthetic). Esse ganho de desempenho varia de 21 ve- zes para o resultado mais lento a 58 vezes para o mais rápido, como pode ser visto na Tabela 5.17.
Observa-se que a implementação OpenCL é mais rápida que a implementação OpenMP, mesmo quando essas estão sendo executadas na mesma CPU. Para se entender esses re- sultados é preciso olhar os contadores de hardware para cada execução, a fim de encontrar
a causa de tal diferença. Para isso, então, um experimento com o uso do perf é necessário, já que esse programa é capaz de acessar os contadores de eventos de hardware. Pode-se ver os contadores que são de alguma forma relevantes abaixo.
• cycles : total de ciclos até o fim da execução. • instructions : total de instruções executadas.
• LLC-loads : número total de carregamento de dados da cache de último nível. • LLC-load-misses : número total de erros na cache de último nível.
cycles instructions LLC-loads LLC-load-misses CMPOCL 6,34 × 1011 5,75 × 1011 7,11 × 109 2,79 × 107
CMPOMP 2,66 × 1012 1,73 × 1012 1,42 × 108 8,28 × 106
Tabela 5.18: Resultados do perfilamento das aplicações CRS-OpenCL e CMP-OpenMP. Os resultados obtidos pelos experimentos realizados utilizando o perf podem ser vistos na tabela 5.18. Com os resultados pode-se ver que a implementação com OpenMP executa um número muito maior de instruções (aproximadamente três vezes mais instruções em relação a implementação OpenCL), além disso, pode-se verificar que essas instruções também levam mais tempo para serem executadas, já que o CRS-OpenMP executa 0,66 instruções por ciclo enquanto que a implementação OpenCL executa 0,9 instruções por ciclo. Realizando uma inspeção do código gerado pelo compilador para a implementação OpenMP, pode-se ver claramente a ausência de instruções vetoriais do tipo AVX [26], enquanto que esse fato não ocorre com a implementação OpenCL. Esses fatores explicam o ganho de desempenho da implementação OpenCL em relação a OpenMP. Como já discutido na seção sobre os resultados do CMP, não tem sentido prático implementar o código utilizando-se de artifícios para forçar o uso de instruções vetoriais disponíveis em uma certa arquitetura, já que dessa maneira o código ficaria preso a essa arquitetura. Dessa forma, espera-se que o compilador seja capaz de realizar essa otimização.
Usando a métrica descrita na equação 5.10 pode-se fazer uma comparação do desempe- nho do CRS entre os dados de entrada de uma maneira justa. Os dados dos experimentos de desempenho, anteriormente apresentados, podem ser vistos dessa nova maneira no gráfico da figura 5.19.
Figura 5.19: Resumo dos resultados experimentais para CRS usando como métrica a equação 5.10.
Pode-se inferir novas informações com base nessa nova representação dos dados de desempenho mostrada na Figura 5.10: como que o CRS-OpenCL tem um desempenho melhor para o dado de entrada Jequitinhonha em todas as plataformas e tem o pior desempenho quando processa o dado Micro-synthetic.
Observando a Figura 5.19, a primeira característica que pode ser notada é que o dado Jequitinhonha consegue ser processado de maneira mais eficiente do que os restantes em todos os dispositivos disponíveis e em todas as implementações feitas. Além disso, quando o gráfico da Figura 5.19 é comparado com o gráfico da Figura 5.8, observa-se que o CRS é executado de maneira mais eficiente em relação ao CMP. Esses dois fatos estão correlacionados a um terceiro, que é o desempenho da R9-290x, que se mostra muito melhor em relação às outras GPUs usadas nos experimentos. Esses resultados podem ser explicados pela intensidade operacional intrínseca do CRS que é, naturalmente, maior em relação a do CMP. Tal fato pode ser melhor compreendido quando se observam os modelos rooflines derivados dos experimentos com a implementação CRS-OpenCL que podem ser observados no Apêndice B.