Análise Detalhada

Além de medir o tempo de execução com inline desligado e ligado, durante a análise experimental foram coletadas para alguns programas informações de hardware através da ferramenta Performance Application ProgrammingInterface (PAPI) [Terpstra et al. 2010]. As informações mais importantes quando se trata da otimização inline são: quantidade de instruções por ciclo (IPC) e acessos à memória cache.

Para o compilador Cliente os experimentos foram realizados para SEARCH e FASTA. SEARCH apresentou o mesmo IPC, para inline desligado ou ligado. Já FASTA obteve uma redução do IPC, passando de 0,84 para 0,75 instruções por ciclo, quando a otimização inline foi ligada. Estes resultados demonstram que a otimização causa um efeito negativo para o Fasta, quanto à quantidade de instruções executadas por ciclo.

Esta redução de IPC é uma das causas da degradação de desempenho deste programa.

Para o compilador Servidor os experimentos foram realizados apenas para EULER, MOLDYN, FASTA, N-BODY e SPECTRAL. Não foram coletadas informações para os outros programas (que obtiveram uma queda de desempenho) devido ao fato da ferramenta utilizada não funcionar corretamente para o benchmark DaCapo.

EULER e MOLDYN apresentaram um pequeno aumento no IPC utilizando inline (0,91 para 0,92 e 1,45 para 1,46 respectivamente). FASTA obtive uma redução

Anais do 9^o. Fórum de Informática de Maringá – 13 a 17 de Setembro de 2010 116 de IPC passando de 0,92 para 0,89. E N-BODY se manteve estável, este foi um dos motivos que o levou a ter um desempenho insignificante.

Outros experimentos foram realizadas com os mesmos programas para avaliar o acesso à memória. Para o compilador Cliente os dois programas apresentaram uma redução na quantidade de acertos à cache (de 1,64% para SEARCH e 1,93% para FASTA). Para SEARCH esta redução não ocasionou em uma perca de desempenho. FASTA ainda apresentou um aumento de 3% na quantidade de acessos à cache, ocasionando uma perca de desempenho. Isto demonstra que a qualidade do código gerado pelo compilador cliente (utilizando inline) para estes programas não possui uma boa localidade.

Já no compilador Servidor os resultados foram mais variados. EULER apresentou um aumento, tanto para os acertos, quanto para os erros de acesso à cache. Porém, os erros aumentaram em 5,17%, enquanto os acertos aumentaram em apenas 1,43%. Este é um dos motivos deste programa ter perda de desempenho, pois muitos erros de acesso a memória cache ocorrem, quando a otimização é ligada.

Para MOLDYN OS aumentos na quantidade de acessos e erros foi insignificante (de 0,09% e 0,58% respectivamente). Embora estes dados não indiquem o que ocasionou a perda de desempenho de 27,79%, possivelmente isto foi ocasionado pelo tempo gasto pelo compilador. Como o compilador Servidor é um compilador agressivo, ele tende a gerar um alto tempo de compilação.

FASTA apresentou números negativos nos dois aspectos. A quantidade de erros de acesso aumentou em 4,25% e a quantidade de acertos de memória aumentou em 19,05%. Estes dados demonstram que a utilização da cache, quando a otimização inline foi ligada, foi prejudicial para a execução. Neste caso, ocorreu o mesmo problema ocasionado com o compilador Cliente, o código gerado pelo compilador Servidor possui uma qualidade baixa, ocasionando em uma má localidade.

N-BODY se manteve estável também quanto aos acessos à cache, obtendo apenas um aumento na quantidade de erros de 0,87% e um aumento insignificante na quantidade de acertos de 0,001%. Mesmo com este aumento nos erros de acesso, o desempenho deste programa se manteve consideravelmente estável. For fim, para SPECTRAL O USO de inline não teve impacto na quantidade de acessos à cache, contudo ocasionou uma redução de 35,14% na quantidade de acertos.

Consequentemente, ocasinando uma perca de desempenho.

5. Considerações Finais

Em geral, os trabalhos que descrevem ambientes Java com compilação dinâmica, não apresentam uma análise detalhada do impacto das otimizações aplicadas pelo compilador. Embora, alguns trabalhos [Gu et al. 2000, Cierniak et al. 2000, BURKE et al. 1999] destaquem a importância da aplicação de inline não descrevem a heurística utilizada, nem apresentam o ganho real obtido por esta otimização. Este trabalho descreve de forma detalhada a heurística utilizada na aplicação de inline pela máquina Virtual Java da Sun, como também apresenta uma análise detalhada do ganho de desempenho obtido por esta otimização.

A aplicação de inline realizada pelo compilador Cliente se mostrou mais eficiente. Apenas um programa, obteve perda de desempenho. Por outro lado, a agressividade do compilador Servidor se torna prejudicial em muitos casos,

ocasionando uma perca de desempenho significativa em alguns casos. Outro aspecto interessante é que o tempo de execução é drasticamente reduzido quando chamadas de métodos nativos sofrem a aplicação de inline. Em média, os programas utilizando o compilador Cliente obtiveram uma melhora de 26,25% no seu desempenho. Por outro lado, utilizando o compilador Servidor, estes programas obtiveram uma média geral de 6,67%. Esta diferença comprova que nem sempre a agressividade será a escolha correta.

Um trabalho futuro compreende desenvolver uma heurística dinâmica de aplicação de inline. Desta forma, os parâmetros que controlam esta otimização não serão mais estáticos, mas dinâmicos, podendo ser ajustado dependendo do perfil do programa em execução.

Referências

Abboy, M. B. and Peterson, L. L. (1992). A Language-Based Approach to Protocol Implementation. Computer Communications Review, 22 (4): 27-37.

Bernstein, D., Cohen, D., and Krawczyk, H. (1991). Code duplication: an assist for global instruction scheduling. In Proceedings ofthe International Symposium on Microarchi-tecture, pages 103-113, New York, NY, USA. ACM.

Bernstein, D., Golumbic, M., et al. (1989). Spill Code Minimization Techniques for Optimizing Compilers. In Proceedings ofthe Conference on Programming Language Design andImplementation, pages 258-263, Portland, Oregon. ACM.

Blackburn, S. M., Garner, R., et al. (2006). The DaCapo Benchmarks: Java Benchmark-ing Development and Analysis. In Proceedings ofthe Conference on Object-oriented Pogramming Sstems, Lnguages, and Applications, volume 41, pages 169-190, USA. ACM.

Brent Fulgham (2010). The Computer Language Benchmark Game. http://

s h o ot o u t. ali o th . d ebian . o rg/ ; aces s o em 20 d e Março 2 0 1 0.

Bull, M., Smith, L., Westhead, M., Henty, D., and Davey, R. (2000). Benchmarking Java Grande Applications. In Proceedings ofthe International Conference on The Practical Applications of Java, pages 63-73.

BURKE, M. G., CHOI, J.-D., et al. (1999). The Jalapefío Dynamic Optimizing Compiler forjava. Java Grande Conference, pages 129-141.

Chen, W. Y, Chang, P. P., et al. (1991). The Effect of Code Expanding Optimizations on Instruction Cache Design. In CRHC-91-17, Center for Reliable and High-Performance Computing, University of Illinois. IEEE Computer Society.

Cierniak, M., Lueh, G.-Y, and Stichnoth, J. M. (2000). Practicing JUDO: Java Under Dynamic Optimizations. In Proceedings ofthe Conference on Programming Languages Design and Implementation, Vancouver, Canadá. ACM SIGPLAN.

da Silva, A. F. and Santos Costa, V. (2006). Our Experiences with Optimizations in Sun's Java Just-in-time Compilers. In Proceedings of the Brazilian Symposium on Programming Languages, pages 51-65, Brasil. SBC.

Deutsch, L. P. and Schiffman, A. M. (1984). Efficient implementation ofthe smalltalk-80 system. In POPL '84: Proceedings ofthe 11th ACM SIGACT-SIGPLAN

Anais do 9^o. Fórum de Informática de Maringá – 13 a 17 de Setembro de 2010 118 symposium on Principles ofprogramming languages, pages 297-302, New York, NY, USA. ACM.

Gu, W., Burns, N. A., et al. (2000). The Evolution of a High-Performing Java Virtual Machine. IBMSytems Journal, 39(1): 135-150.

Meyer, J. and Downing, T. (1997). Java Virtual Machine. O'Reilly, USA, 1 edition.

MicroSystems, S. (2010). The Java HotSpot Virtual Machine. Technical report, Sun Developer Network Community.

Muchnick, S. S. (1997). Advanced Compiler Design And Implementation. Morgan Kauf-mann, San Francisco, CA, USA.

Scott, M. L. (2008). Programming Language Pragmatics. Elsevier, 3 edition.

Terpstra, D., Jagode, H., You, H., and Dongarra, J. (2010). Collecting Performance Data with PAPI-C. In Proceedings ofthe Parallel Tools Workshop, pages 63-73, Germany. Springer Verlag.