Java não é mais tão lento Hugo Braga Martins 1, Fabiano C. Botelho 2,3 (Orientador) 1 Departamentode Informática Faculdade Cotemig Belo Horizonte Brasil 2 Departamento de Ciência da Computação Universidade Federal de Minas Gerais Belo Horizonte Brasil 3 Departamento de Engenharia da Computação Centro Federal de Educação Tecnológica de Minas Gerais Belo Horizonte Brasil hbmnet@hotmail.com e fbotelho@dcc.ufmg.br Abstract. We have two goals in this article. First, we study how the performance of the different versions of the Java Virtual Machine has evolved. Second, we compare the performance of programs written in Java and C++ to have an upper bound for the maximum performance that can be obtained, since it is well known that the compilers for the C++ language generate more efficient codes. For this we have used exact string matching algorithms written in Java and in C++. We used two metrics: (i) processing time and (ii) time to sequentially read data from disk. We note that the Java virtual machines have evolved considerably and the processing time of programs written in Java is very close to that obtained with programs written in C++. However, with regard to the time of the sequential disk access, we see that the performance of programs written in C++ is much better than that of programs written in Java, even in version 6 of the Java language. Programs written in Java in version 6 are on average 444% slower than those written in C++, showing that Java still has much to evolve in terms of sequential access to disk. Resumo. Este artigo tem dois objetivos. Primeiro, estudar a evolução do desempenho das máquinas virtuais Java nas suas diferentes versões. Segundo, comparar o desempenho de programas escritos em Java e em C++ para se ter um limite superior para o desempenho máximo que pode ser obtido, uma vez que compiladores para a linguagem C++ reconhecidamente geram códigos mais eficientes. Para isso utilizamos algoritmos de busca em texto escritos em Java e em C++. Foram utilizadas duas métricas: (i) tempo de processamento e (ii) tempo de leitura seqüencial em disco. Verificamos que as máquinas virtuais Java têm evoluído bastante e o tempo de processamento de programas escritos em Java está muito próximo daquele obtido com programas escritos em C++. No entanto, no que diz respeito ao tempo de acesso seqüencial a disco, verificamos que o desempenho dos programas escritos em C++ é bem superior ao dos programas escritos em Java, mesmo na versão 6 da linguagem Java. Programas escritos em Java na versão 6 são em média 444% mais lentos do que os escritos em C++, mostrando que Java ainda tem muito que evoluir em termos de acesso seqüencial a disco.
1. Introdução A Web, principal catalisador da revolução da informação que vivemos hoje, provocou uma mudança significativa na forma de se desenvolver softwares. Isso se deve à facilidade e ao baixo custo de publicação de informações na rede, o que foi intensificado ainda mais com o surgimento das aplicações da Web 2.0, tais como Flickr 1, YouTube 2, entre outras. Por conseqüência, o desenvolvimento de softwares para desktops e supercomputadores tende a desaparecer, uma vez que os usuários desejam ter acesso à informação em qualquer instante e de qualquer lugar. Em contrapartida, o desenvolvimento de softwares distribuídos e para dispositivos móveis tem se tornado cada vez mais presente atualmente [Balbino 2006, Eis 2006, Negroponte 2007]. O fenômeno de democratização de uma mídia de alcance mundial tem tornado o uso da linguagem Java cada vez mais popular para produção de softwares para Web. É importante salientar que a linguagem Java possui uma série de facilidades que aceleram o desenvolvimento, além de possuir muitos códigos publicados, e conseqüentemente diversos fóruns de discussão que auxiliam os usuários na busca de soluções. Em contrapartida, tal linguagem não é considerada apropriada para desenvolvimento de aplicações com altos requisitos de desempenho. A principal razão é que durante a execução de um programa existem recursos que o programador não consegue controlar durante a escrita do código, e que podem provocar altas variações no tempo de execução. Por exemplo, o processo de Garbage Collection [Zorn 1993]. Neste trabalho temos dois objetivos. Primeiro, estudar a evolução do desempenho das máquinas virtuais Java nas suas diferentes versões. Segundo, comparar o desempenho de programas escritos em Java e em C++. A linguagem C++ foi escolhida para se ter um limite superior para o desempenho máximo que pode ser obtido, uma vez que compiladores para a linguagem C++ reconhecidamente geram códigos mais eficientes. Além disso, C++ é a principal linguagem utilizada para o desenvolvimento de aplicações com altos requisitos de desempenho. Portanto, estudamos duas perguntas neste artigo. Qual a diferença de desempenho entre programas escritos em Java em relação aos respectivos programas escritos em C++? Como esta diferença de desempenho vem evoluindo nas diferentes versões das máquinas virtuais Java? A principal contribuição deste artigo é uma comparação evolutiva do desempenho das máquinas virtuais Java em relação ao desempenho de programas escritos em C++. Na seção 2 descrevemos as métricas e a metodologia utilizadas neste estudo. Na seção 3 apresentamos os resultados obtidos. Na seção 4 apresentamos alguns trabalhos relacionados a este estudo. Na seção 5 discutimos alguns pontos que devem ser considerados antes de escolher dentre Java e C++ para desenvolver um projeto. Na seção 6 apresentamos as conclusões deste trabalho. 2. Metodologia Neste trabalho utilizamos duas aplicações para estudar a evolução das máquinas virtuais Java e comparar tal evolução com o desempenho das mesmas aplicações implementadas em C++. Foram escolhidas as máquinas virtuais a partir da versão 3 até a versão 6 que é a mais recente. Não foi possível avaliar as versões 1 e 2 porque a execução dos 1 Flickr. Site para compartilhamento de fotos, disponível em: http://www.flickr.com 2 Youtube. Site para compartilhamento de vídeos, disponível em: http://www.youtube.com
algoritmos provocou a ocorrência da exceção OutOfMemoryError na classe ByteArrayOutputStream, que é utilizada para armazenar os dados em memória. As aplicações implementadas são utilizadas para resolver o problema de casamento exato de padrão em um texto, o qual é formalizado da seguinte forma. O texto é um arranjo T[0..n-1] de tamanho n, o padrão é um arranjo P[0..m-1] de tamanho m n. Os elementos de P e T são escolhidos de um alfabeto finito Σ de tamanho c. Por exemplo, podemos ter Σ = {0,1} ou Σ = {a,b,...,z}. Dadas duas cadeias P (padrão) de comprimento P = m e T (texto) de comprimento T = n, em que n» m, deseja-se saber todas as ocorrências de P em T. As aplicações são: (i) Boyer, Moore, Horspool e Sunday (BMHS) [Ziviani 2006] e (ii) Shift-And Exato (SAE) [Ziviani 2006]. Em 1977, Boyer e Moore publicaram o primeiro algoritmo com complexidade de caso médio O(n/m) para resolver o problema de casamento exato de padrão em texto, o qual ficou conhecido com BM. Em 1980, Horspool apresentou uma simplificação importante no algoritmo original, mantendo a complexidade de caso médio, mas tornando o algoritmo ainda mais eficiente na prática. Este algoritmo ficou conhecido como BMH. Em 1990, Sunday apresentou outra simplificação importante sobre o BMH, a qual ficou conhecida como BMHS. O enfoque dos algoritmos BM, BMH e BMHS é procurar o padrão P da direita para esquerda em uma janela que desliza sobre o texto T. Em [Ziviani 2006] é apresentado uma descrição detalhada desses algoritmos. Em 1989, Baeza-Yates e Gonnet propuseram um algoritmo que tira proveito do paralelismo intrínseco existente nas operações sobre bits dentro de uma palavra de computador. O algoritmo ficou conhecido como Shift-And Exato (SAE). O algoritmo possui uma complexidade de caso médio O(n), que é pior do que a complexidade de caso médio O(n/m) do BMHS. Para detalhes sobre o SAE consulte [Ziviani 2006]. Foram utilizadas duas métricas nos experimentos: (i) tempo de acesso seqüencial a disco (E/S) e (ii) tempo de processamento ou de UCP (Unidade Central de Processamento). O tempo de E/S corresponde ao tempo necessário para se ler seqüencialmente um arquivo texto de 100 MB e o tempo de processamento corresponde ao tempo para pesquisar o padrão new york no texto lido. As duas aplicações foram implementadas para terem o mesmo padrão de acesso a disco. Ou seja, primeiro todo o texto é lido seqüencialmente para memória, tomando o cuidado de limpar o buffer de E/S antes de cada execução. Além disso, as duas aplicações escolhidas implementam algoritmos com complexidades e operacionalização totalmente diferentes. Por conseqüência, utilizam a UCP de forma diferenciada, permitindo medir a evolução do tempo de processamento sobre diferentes cargas. É importante ressaltar que o tempo de operações de E/S em Java é muito sensível a API (Application Programming Interface) de E/S utilizada. Assim, para obter o melhor desempenho em todas as versões da máquina virtual estudadas, foram utilizadas as classes FileInputStream para ler o arquivo em blocos de 4KB e a classe ByteArrayOutputStream para armazenar os blocos lidos em memória principal. A escolha do tamanho do bloco de leitura é uma decisão importante para o desempenho das operações de E/S. O valor de 4 KB foi determinado a partir do tamanho do bloco de leitura padrão do sistema operacional instalado: Linux versão 2.6. Para as
implementações em C++, o mesmo tamanho de bloco de leitura foi utilizado e a função fread foi a utilizada para realizar a leitura seqüencial dos dados do disco. 3. Resultados Nesta seção apresentamos os resultados experimentais para comparar as versões da máquina virtual, tendo as implementações em C++ como limite superior de desempenho. Como sugerido em [George et al. 2007], todos os valores apresentados são médias sobre 100 medições de forma a garantir um nível de confiança de 95 % nos resultados apresentados para a linguagem Java nas versões 3, 4, 5 e 6, e para a linguagem C++. Todos os experimentos foram realizados em uma máquina com processador Intel P4 2.8 GHz, com 1 GB de memória principal e com o sistema operacional Linux versão 2.6. É importante observar que nossos experimentos foram feitos utilizando os mesmos algoritmos e as mesmas estruturas de dados, tanto na linguagem Java, quanto na linguagem C++. Outra questão a salientar é que a máquina estava dedicada exclusivamente para a realização dos experimentos, ou seja, desligada da internet e sem nenhum outro aplicativo em execução. Evitando, assim, problemas de distorções de desempenho [Gu 2006]. O primeiro experimento compara as diferentes versões consideradas para a linguagem Java com a linguagem C++, com relação ao tempo de processamento. Os tempos são medidos em segundos. A Tabela 1 e a Figura 1 apresentam as médias e os desvios padrões do tempo para se pesquisar o padrão new york em um texto de 100 MB variando os algoritmos de busca considerados. Como esperado, a máquina virtual 3 é a de pior desempenho. A máquina virtual 4 é 29% mais lenta do que a 5 para o BMHS e 1% mais lenta para o SAE. Já a máquina virtual 5 é aproximadamente 24% mais lenta do que a 6 para o BMHS e 13 % mais lenta para o SAE. Isto demonstra que o desempenho da máquina virtual 6 evoluiu consideravelmente em relação as outras. Notamos ainda que quase não existe diferença de desempenho para o BMHS escrito em Java e em C++. Já para o SAE, a máquina virtual Java 6 é 57% mais lenta em relação ao mesmo programa escrito em C++. UCP Linux BMHS SAE Média Desvio Média Desvio Java 3 0,8674 0,0270 1,6348 0,0740 Java 4 0,6939 0,4479 1,3079 0,3180 Java 5 0,5355 0,0090 1,2938 0,1001 Java 6 0,4307 0,0488 1,1469 0,0092 C++ 0,4350 0,0150 0,7295 0,0170 Tabela 1: Tempos de execução em segundos para se pesquisar o padrão new york em um texto de 100 MB.
Aplicações vs. Tempo de Processamento 1,800 1,600 1,400 TEMPO DE BUSCA (s) 1,200 1,000 0,800 0,600 0,400 0,200 0,000 BMHS Aplicações SAE JAVA 3 JAVA 4 JAVA 5 JAVA 6 C++ Figura 1: Tempos de execução em segundos para se pesquisar o padrão new york em um texto de 100 MB. O segundo experimento foi para analisar o tempo de leitura seqüencial em disco para as aplicações escritas em Java e em C++. Novamente os tempos são apresentados em segundos. A Tabela 2 apresenta as médias e os desvios padrões para se ler seqüencialmente o arquivo de 100 MB do disco. Ao testar os algoritmos nas diferentes máquinas descobrimos diferenças de desempenho, e a maior surpresa é que a máquina Java 5 é estatisticamente equivalente à máquina Java 4 no que diz respeito ao tempo para ler seqüencialmente um arquivo para memória. Já a máquina Java 5 é em média 140% mais lenta do que a Java 6 para ler o mesmo arquivo. Observamos também que a aplicação escrita em C++ é muito superior no que diz respeito à leitura seqüencial do arquivo, uma vez que o programa em Java executado na máquina virtual 6 é 444% mais lento. É importante ressaltar que tanto o BMHS quanto o SAE realizam a leitura do arquivo da mesma forma. Portanto, os tempos e desvios apresentados englobam as 200 execuções das duas aplicações. Leitura Linux Média Desvio Java 3 6,658 0,051 Java 4 5,083 0,306 Java 5 5,132 0.239 Java 6 2,135 0,169 C++ 0,380 0,010 Tabela 2: Tempo em segundos para se ler seqüencialmente um arquivo texto de 100 MBs. A Figura 2 nos ajuda a visualizar melhor os resultados e perceber a grande diferença que ainda existe entre as aplicações escritas em Java e em C++, no que diz respeito a operações de E/S. Também é possível observar a ligeira diferença entre as
máquinas virtuais 4 e 5, e a grande evolução da máquina virtual 6, onde o desempenho é bem superior do que nas máquinas 4 e 5. Aplicações vs. Tempo de Leitura 6 5 TEMPO DE LEITURA (s) 4 3 2 1 0 Aplicações JAVA 3 JAVA 4 JAVA 5 JAVA 6 C++ Figura 2: Tempo em segundos para se ler seqüencialmente um arquivo texto de 100 MBs. As questões que surgem são: (i) por que a diferença dos tempos de processamento não é tão grande, sabendo que os bytecodes Java são interpretados pela máquina virtual enquanto que os programas C++ são diretamente compilados para a arquitetura onde serão executados? (ii) Por que a diferença de desempenho considerando o tempo de (E/S) ainda é tão expressiva? Como discutido em [Wikipedia 2008], as principais evoluções da máquina virtual 6 que afetam diretamente o tempo de processamento são: 1. Realização da verificação dos bytecodes tanto na compilação quanto na execução. Na prática esta técnica funciona porque captura os conhecimentos que o compilador tem da ordem de processamento das classes e registram uma sinopse desta ordem nos bytecodes. Isto não garante que a verificação durante a execução será menos complexa, mas permite realizar alguns atalhos. 2. Melhora no processo de alocação dos registradores. Esta técnica utiliza algoritmos de coloração de grafos para permitir a reutilização de registradores através de blocos de código. Isto reduz consideravelmente o fluxo de dados entre a memória e os registradores, aumentando em até 60% o desempenho. Já no que diz respeito ao tempo de E/S, o principal fator que afeta o desempenho são as chamadas de sistema. Quando os dados referentes a uma operação de leitura não são encontrados no buffer de E/S, o programa Java realiza uma chamada de sistema à máquina virtual, a qual deve ser redirecionado para o sistema operacional. Ou seja, o fato dos programas escritos em C++ serem compilados diretamente para a arquitetura remove um nível de indireção no processamento de operações de E/S, aumentando assim o desempenho. Já no Java essa atividade é mais lenta porque existe uma máquina
virtual entre o software e o sistema operacional, forçando a execução de um número maior de chamadas de sistema. 4. Trabalhos Relacionados Nesta seção apresentamos os principais trabalhos relacionados a este estudo. O objetivo é delimitar o contexto no qual este trabalho está inserido e realçar as nossas contribuições. O trabalho de Santos, apresentado em [Santos 2007], descreve uma série de técnicas para melhorar o desempenho de E/S do Java. As técnicas utilizadas para acelerar a leitura de arquivos em disco são divididas em: Técnicas de baixo nível: i) regras básicas para acelerar E/S; ii) custos de formatação; iii) acesso randômico. Técnicas de alto-nível: i) compressão; ii) caching; iii) tokenization; iv) serialização; v) obtenção de informações sobre os arquivos; vi) informações adicionais. Em [Lewis et al. 2004], é comparado o desempenho de aplicações escritas em C++ e em Java. O estudo foi realizado considerando a máquina virtual 3. Vários benchmarks foram considerados e a conclusão foi que as aplicações escritas em Java eram significativamente mais lentas do que as mesmas aplicações escritas em C++. Diferentemente do trabalho de Lewis et al., [Chandra et al. 2005] comparam a sintaxe da linguagem Java com a linguagem C#. Em [Libman et al. 2005], os autores comparam o desempenho de E/S de dois padrões de projeto de E/S de alto desempenho implementados em Java e em C++. Os autores concluíram no estudo que a implementação em C++ era mais eficiente do que a implementação em Java executada na máquina virtual 4. Além disso, eles também mostraram que a implementação em Java é mais eficiente na máquina virtual para Linux do que na máquina virtual para Windows. Em [Ulrich 2001] foram testados diferentes versões do algoritmo de ordenação pelo método da bolha genérico (generic bubble sort), com o objetivo de verifcar as variações de desempenho de implementações em Java e em C++ rodando em diferentes ambientes: Windows e Linux. Para testar o generic bubble sort foram construídas 4 implementações em C++ e 3 implementações em Java utilizando diferentes estruturas de dados. Em C++, como já era esperando, obteve-se um resultado melhor do que em Java. A implementação C + + STL, onde STL significa Standard Template Library, que utiliza iterators e a função swap da biblioteca STL teve um desempenho melhor do que as demais implementações, que são: (i) C++ pointer, que utiliza um arranjo de ponteiros para objetos alocados dinamicamente, (ii) C++ object, que utiliza um arranjo de objetos e (iii) C++ vector que utiliza a classe vector da STL para formar um arranjo de objetos. Já no Java, a implementação utilizando arranjo (Java Array) foi mais eficiente do que a que utiliza a classe ArrayList (Java Array List), que armazena uma lista de objetos de referências e provê acesso como em um arranjo. Vale ressaltar que a implementação que utiliza a classe Vector (Java Vector) apresentou o pior desempenho, pois antes da ordenação é realizada uma cópia dos objetos de referências armazenados no vetor. As implementações em Java foram avaliadas nas máquinas virtuais 1.1 e 1.2.
Em [Reinholtz 2000] foi mostrado, em um contexto bem específico, que o desempenho de programas escritos em Java pode ser melhor do que em C++, porque a compilação dinâmica da acesso ao compilador Java à informações de tempo de execução que não estão disponíveis para o compilador C++. Isto é importante para direcionar o desenvolvimento de técnicas que podem estender a vida útil de uma bateria em um sistema embutido. Em [Wikipedia 2008] é apresentado um trabalho destinado a identificar as evoluções de cada máquina virtual desde 1 a 6. Importante salientar que aquele trabalho não é destinando a comparar o desempenho de cada máquina virtual, como fazemos neste estudo, e sim, apresentar a evolução tecnológica de cada maquina virtual. Ou seja, são apresentadas as técnicas de otimização acrescida em cada máquina virtual e suas melhorias. Como exemplo, compilação Just-In-Time por HotSpot no Java 1.3, dentre outras. Os trabalhos relacionados abordam assuntos como otimização de E/S no Java [Santos 2007], diferença de desempenho do C++ e do Java para uma máquina virtual específica [Lewis et al. 2004], diferença de desempenho do Java no Linux e no Windows [Libman et al. 2005], impacto das diferentes estruturas de dados com funcionalidades semelhantes no tempo de execução de programas que as utilizam[ulrich 2001], tanto em Java quanto em C++, e evolução dos recursos incorporados à maquina virtual, sem mensurar o impacto das melhorias no tempo de aplicações reais[wikipedia 2008]. A principal contribuição deste estudo é uma comparação evolutiva, em termos de desempenho de E/S e processamento, nas máquinas virtuais 3, 4, 5 e 6. Além disso, também é mostrado uma comparação com a linguagem C++, a qual mostra que a maquina virtual Java ainda tem muito a evoluir para que os programas escritos em Java tenham o mesmo desempenho dos mesmos programas escritos em C++ (vide Seção 3). 5. Desenvolver em C++ ou em Java? Uma decisão importante durante o desenvolvimento de um projeto é a linguagem a ser adotada. Este é um trabalho bastante complexo e, portanto, exige muita experiência. Nesta seção discutimos as métricas que julgamos importantes para se escolher dentre Java e C++, as quais são: Produtividade, Desempenho e Custo. Produtividade: a linguagem Java tem se tornado cada vez mais popular, pois aumenta a produtividade dos programadores. A principal razão para isto é o fato da linguagem retirar a responsabilidade de gerência de memória do programador e, transferi-la para a máquina virtual, através do processo de Garbage Collection. Já em C++, o programador é o responsável por gerenciar a memória alocada e, em muitas situações, são gerados erros de difícil detecção, consumindo um tempo considerável para se depurar os programas. [Kaplan 2001] discute as vantagens do processo de Garbage Collection que determinam o aumento da produtividade dos programadores. Desempenho: diante do que foi apresentado na Seção 3, aplicações com requisitos extremos de desempenho, como aplicações de tempo real, máquinas de busca e outras, devem ser desenvolvidas em C ou C++. Além disso, existem algumas facilidades em Java, como o processo de Garbage Collection, que foge do controle
do programador e que pode provocar altas variações nos tempos de execução dos programas. Em contrapartida, a linguagem Java tem evoluído bastante a cada versão e esta diferença tem diminuído significativamente. Custo: o custo é um fator muito importante para o sucesso de qualquer projeto. Assim, como saber qual a linguagem terá um menor custo para desenvolver um projeto? Após algumas pesquisas nas principais máquinas de busca verticais de jobs 3, descobrimos que os salários de profissionais em C++ e Java varia muito, sendo influenciado por vários fatores como a natureza do projeto, empresa, currículos, etc. Mas, em geral, observamos que profissionais bons de C++ estão escassos no mercado de trabalho e seus salários são mais altos do que os de Java. Isto não quer dizer que desenvolver um projeto em Java fique mais barato do que desenvolver em C++, devido a um detalhe muito importante: o objetivo do projeto. Com base no objetivo do projeto é possível medir qual a melhor linguagem para desenvolvê-lo, visando um custo mais baixo. Por exemplo, se o projeto for desenvolver uma máquina de busca, onde o desempenho é crucial para satisfação dos usuários, é melhor investir mais em uma equipe C++ para desenvolver programas mais eficientes e economizar na infra-estrutura necessária para atender a demanda por processamento de consultas. Já em situações de pequenos projetos, onde a premissa de desempenho não é tão significativa, tornase mais econômico desenvolver o projeto em Java, pois a mão-de-obra é mais barata uma vez que a produtividade é maior. Assim, na escolha da linguagem, deve-se analisar os compromissos existentes nos objetivos de cada projeto. 6. Conclusões Neste artigo apresentamos a evolução de desempenho das máquinas virtuais Java e comparamos a diferença de desempenho que existe para aplicações escritas em Java e em C++. Verificamos que, no que diz respeito ao tempo de processamento, a diferença entre C++ e Java não é mais tão significativa e vem diminuído a cada versão da máquina virtual (veja, por exemplo, Figura 1). Já em relação ao tempo para se ler um arquivo seqüencialmente do disco, verificamos que a máquina virtual ainda precisa evoluir muito, pois a diferença de desempenho é ainda considerável (veja, por exemplo, Figura 2). Este trabalho vem então contribuir para o entendimento da evolução das máquinas virtuais Java com relação ao C++ tanto em termos de tempo de processamento, quanto em tempo de leitura seqüencial em disco. Como trabalho futuro, pretendemos estudar também a influência de acesso randômico a disco para aplicações escritas em C++ e em Java nas diferentes versões da máquina virtual. 3 Vagas. Site de recrutamento de recursos humanos. disponível em: http://www.vagas.com.br
7. Agradecimento Ao Prof. Luís Fabrício W. Góes pelas idéias e informações discutidas durante a realização deste trabalho. A Gustavo Maia pela ajuda com as implementações. Ao apoio parcial dado pelo projeto INFOWEB, processo MCT/CNPq/CT-INFO 550874/2007-0. 8. Referências Balbino, J. (2006). Mobilidade em Educação. Disponível em: <http://www.dicasl.com.br/educacao_tecnologia/educacao_tecnologia_20060929>. Acesso em: 02 de Setembro de 2008. Chandra, S. S. and Chandra, K. (2005). A comparison of Java and C#. Journal of Computing Sciences in Colleges, 20(3):238 254. Eis, D. (2006). Sites para Dispositivos Móveis - Breve introdução. Disponível em: <http://www.tableless.com.br/sites-para-dispositivos-moveis-breve-introducao>. Acesso em: 02 de Setembro de 2008. Georges, A., Buytaert, D. and Eeckhout, L. (2007). Statistically rigorous java performance evaluation. In Proceedings of the 22nd annual ACM SIGPLAN conference on Object oriented programming systems and applications (OOPSLA 07), pages 57 76. ACM Press. Gu, D., Verbrugge, C. and Gagnon, E. M. (2006). Relative factors in performance analysis of Java virtual machines. In Proceedings of the 2nd International Conference on Virtual Execution Environments (VEE'06), pages 111 121. ACM Press. Kaplan, I. (2001). Memory Allocation and Garbage Collection. Disponível em: <http://www.bearcave.com/software/garbage.htm>. Acesso em: 02 de Setembro de 2008. Lewis, J. P. and Neumann, U. (2004). Performance of Java versus C++. Disponível em <http://www.idiom.com/~zilla/computer/javacbenchmark.html>. Acesso em 02 de Setembro de 2008. Libman, A. e Gilbourd, V. (2005). Comparing Two High-Performance I/O Design Patterns. Artima Developer, disponível em: <http://www.artima.com/articles/io_design_patterns3.html>. Acesso em 02 de Setembro de 2008. Negroponte, N. Online Laptop per Child OLPC (2007). Disponível em: <http://laptop.org/vision/index.shtml>. Acesso em: 02 de Setembro de 2008. Reinholtz, K. Java will be faster than C++ (2000). ACM Sigplan Notices, 35(2): 25 28. Santos, C. D. S. (2007). Introdução: Técnicas para desempenho de I/O. Disponível em: <http://www.inf.ufrgs.br/procpar/disc/inf01008/trabalhos/sem01-1/t2/pdpt2claus>. Acesso em: 02 de Setembro de 2008. Ulrich, S. (2001) Java vs. C++. Technical Report, Stanford University. Disponível em: <http://verify.stanford.edu/uli/java_cpp.html>. Acesso em 02 de Setembro de 2008.
Wikipedia (2008). Java performance. Disponível em: <http://en.wikipedia.org/wiki/java_performance>. Acesso em: 02 de Setembro de 2008. Ziviani, N. (2006). Projeto de Algoritmos com Implementações em Java e C++. Consultoria em Java e C++ de F.C. Botelho, Thomson Learning, ISBN 8522105251. Zorn, B. (1993). The Measured Cost of Conservative Garbage Collection. Software - Practice and Experience, 23(7): 733-756.