Perf Linux - Comparação entre Java e C++

1

SUMÁRIO

ÍNDICE DE FIGURAS .................................................................................................... 2

ÍNDICE DE TABELAS ................................................................................................... 3

ÍNDICES DE GRÁFICOS ............................................................................................... 4

1. INTRODUÇÃO ........................................................................................................ 5

1.1 OBJETIVO ............................................................................................................ 6

1.2 METODOLOGIA .................................................................................................. 6

2. CONCLUSÃO ........................................................................................................ 14

3. REFERÊNCIAS ...................................................................................................... 15

2

ÍNDICE DE FIGURAS

Figura 1 - Configuração do Sistema de Testes ................................................................ 5

Figura 2 - Código de Ordenação do Bubble Sort em C++ .............................................. 6

Figura 3 - Código de Ordenação do Bubble Sort em Java .............................................. 7

Figura 6 – Algoritmo que gera números aleatórios em C++ ......................................... 11

Figura 7 – Números aleatórios ...................................................................................... 11

3

ÍNDICE DE TABELAS

Tabela 1 - Comparação de uso de recursos entre o código C++ e Java para 19 itens. .. 10

Tabela 2 - Comparação de uso de recursos entre o código C++ e Java para 500 itens. 12

Tabela 3 - Comparação de uso de recursos entre o código C++ e Java para 1000 itens.

........................................................................................................................................ 12

4

ÍNDICES DE GRÁFICOS

Gráfico 1 - Tempo de Execução dos códigos em Java e C++ ........................................ 13

5

1. INTRODUÇÃO

O perf é um software que já vem instalado com o Sistema Operacional Fedora

12 e permite o monitoramento de uso de recursos ou eventos acionados à partir da

execução de um processo. Nós utilizamos este software para realizar a analise de

desempenho de dois códigos de ordenação tipo Bubble Sort, uma desenvolvida em C++

e outra em Java.

Os testes foram realizados um uma máquina Virtual da Sun, Sun Virtual Box

versão 3.1.4r57640, com um processador Core 2 Quad de 2.4 GHz e com 569 MB de

memória RAM e 12 MB de memória de Vídeo, a versão do Sistema Operacional

utilizado foi o Fedora 12 (Figura 1).

Figura 1 - Configuração do Sistema de Testes

6

1.1 OBJETIVO

O objetivo principal do trabalho foi verificar a velocidade de processamento

entre um mesmo algoritmo de ordenação Bubble Sort implementado em duas

linguagens diferentes, em Java e em C++.

1.2 METODOLOGIA

Na Figura 2 encontra-se o código do algoritmo de ordenação Bubble Sort em

C++ e na Figura 3 o código do algoritmo em Java. O compilador utilizado no Fedora 12

foi o gcc++ versão 4.4.2 (GNU Compiler Collection) para o código em C++, para o

código em Java a versão da JDK foi a 6.18.

#include <cstdlib> #include <iostream> #define max 19 using namespace std; void bubble(int v[max],int n); void bubble(int v[max],int n) { int x,i,j; for(i = 0; i < n; i++){ for(j = i+1; j < n; j++) { if (i != j){ if(v[i] > v[j]) { x = v[i]; v[i] = v[j]; v[j] = x; } } } } } int main(int argc, char *argv[]) { int v[max] = {45,12,31,67,89,45,1,89,93,5,6,55,72,102,84,92,93,42,2}; int i; bubble(v,max); for(i=0;i<=max-1;i++) { printf(" %d \n",v[i]); } system("PAUSE"); return EXIT_SUCCESS; }

Figura 2 - Código de Ordenação do Bubble Sort em C++

7

public class bubble_java { public static void main(String[] args) { int[] v = { 45, 12, 31, 67, 89, 45, 1, 89, 93, 5, 6, 55, 72, 102, 84, 92, 93, 42, 2 }; int i; v = bubble(v); for (i = 0; i < v.length; i++) { System.out.println(v[i]); } } private static int[] bubble(int v[]) { int x, i, j; for (i = 0; i < v.length; i++) { for (j = i + 1; j < v.length; j++) { if (i != j) { if (v[i] > v[j]) { x = v[i]; v[i] = v[j]; v[j] = x; } } } } return v; } }

Figura 3 - Código de Ordenação do Bubble Sort em Java

Foram utilizados os comandos ‘perf stat ./Teste’ no Terminal do Fedora para

iniciar o perf para analise do Código de Ordenação Bubble Sort em C++, onde ‘Teste’ é

o nome do arquivo compilado do código de ordenação em C++, e o comando ‘perf stat

java -jar JvB.jar’ para executar o perf na analise do Código de Ordenação Bubble Sort

em Java, onde JvB.jar é o arquivo jar em Java que possui o código fonte executável

representado na Figura 3.

Inicialmente o código de ordenação foi testado para organizar 19 itens, tanto no

código em Java, quanto no código em C++, os resultados estão representados nas

figuras Figura 4 (resultado do comando ‘perf stat’ no código em C++) e Figura 5

(resultado do comando ‘perf stat’ no código em Java). Para o código em C++ (Figura 4)

ele demorou 0,008601413 segundos, e para o código em Java (Figura 5) ele demorou

1,412365112 segundos, a execução do código em Java demorou 1,403763699 segundos

8

à mais do que o código em C++, ou seja, 164,2 vezes mais demorado do que a execução

do código em C++.

A execução do código em C++ usou 7.307805 tarefas de relógio, enquanto a

execução do código em Java usou 251.589910 tarefas de relógio, 34,43 vezes mais do

que a execução do código em C++. Com relação as trocas de contexto, a execução do

código em C++ não utilizou nenhuma, já o código em Java precisou de 446 trocas de

contexto, e nenhum dos dois códigos precisou de migração de CPU. A execução do

código em C++ gerou 233 faltas de páginas, enquanto o código em Java gerou 2820

faltas de página, 12,1 vezes faltas de página à mais do que a execução do código em

C++. Para os itens ciclos, instruções, referências à cache e erros de cache, para ambos as

execuções os valores foram nulos.

Figura 4 - Resultado do comando ‘perf stat’ para o código em C++

9

Figura 5 - Resultado do comando ‘perf stat’ para o código em Java

As figuras Figura 4 e Figura 5 representam o primeiro ensaio, ao total foram

realizados três ensaios, para ordenação de 19 itens, e a média aritmética entre os três

ensaios esta representada na Tabela 1.

10

Tipos de Códigos C++ Java

Tempo de Execução 0,008248068 1,103081950666667

Tarefas de Relógio 7,13 245,96

Trocas de Contexto 0,33 338,67

Migração de CPU 0 0

Faltas de Página 232,67 2818,67

Ciclos 0 0

Instruções 0 0

Referências à cache 0 0


A Tabela 1 contém a média de três ensaios de analise do comando perf no

terminal do Fedora, analisando o item Tempo de Execução, a execução do código de

ordenação para 19 itens do Java, demorou 133,74 vezes mais do que o código em C++,

utilizou 34,49 vezes mais Tarefas de Relógio do que o código em C++, utilizou 1128,9

vezes mais Trocas de Contexto do que o código em C++, gerou 12,12 vezes mais Faltas

de página do que a execução do código em C++, e para os itens Migração de CPU,

Ciclos, Instruções e Referência à cache ambos os resultados foram 0.

Para realizar os testes com 500 e com 1000 itens criamos um código em C++

que gera números aleatórios entre 1 e 1000, de acordo com a Figura 6, observamos que

os números aleatórios foram gerados uma única vez para ambos os códigos de

ordenação, ou seja, os mesmos números foram utilizados no teste de ordenação pelos

códigos em Java e C++, garantindo-se a igualdade do código na hora do teste.

11

#include <cstdlib>

#include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std; int main(int argc, char *argv[]) { int i; /* inicializar o gerador de números aleatórios */ /* com time(NULL) */ srand(time(NULL)); for (i=0; i<500; i++){ /* para gerar números aleatórios de 0 a 500 */ printf("%d, ", rand() % 1000); } printf("\n"); system("PAUSE"); return EXIT_SUCCESS; }

Figura 6 – Algoritmo que gera números aleatórios em C++

Figura 7 – Números aleatórios

As tabelas Tabela 2 e Tabela 3 contêm os resultados da média de 3 execuções e

analise pelo software perf.

12




Trocas de Contexto 1 157,66


Faltas de Página 234 2862

Ciclos 0 0

Instruções 0 0






Trocas de Contexto 2 295,33


Faltas de Página 352 2910

Ciclos 0 0

Instruções 0 0



13

Gráfico 1 - Tempo de Execução dos códigos em Java e C++

De acordo com o Gráfico 1, observa-se que inicialmente o código Java demorou

muito mais para obter o mesmo resultado, que era o da aplicação do algoritmo de

ordenação Bubble Sort para 19 itens, do que o código em C++, posteriormente o código

de Java aproximou-se do código feito em C++, na ordenação de 500 itens, e por fim

para 1000 itens, novamente o código em Java distanciou-se do tempo de execução do

que o código em C++. Observa-se com este gráfico que com o passar o tempo o código

em C++ tende à se comportar como uma função linear de 1º grau, possuindo um

comportamento crescente de tempo de execução de acordo com o aumento do número

de itens à ser ordenado, enquanto o código em Java (com relação aos itens à serem

ordenados e o tempo de execução) parece se comportar, semelhantemente, como uma

função de 2º grau, porém esta analise é muito superficial dado os testes realizados.

A demora do tempo de execução entre as duas linguagens está intimamente

ligada à forma como as linguagens funcionam internamente, pois o Java primeiro

precisa ser interpretado por uma máquina virtual para só então ser executado, neste

ponto o Java ganha em portabilidade de Sistemas sacrificando para isto a performance

de tempo de execução.

14

2. CONCLUSÃO

Com base nos resultados obtidos, percebe-se que a execução do código em Java

apresentou uma performance muito inferior ao do código em C++, isto devido ao

código em Java ser interpretado pela Java Virtual Machine. Porém deve-se ressaltar a

vantagem da linguagem Java quanto à portabilidade oferecida pela Java Virtual

Machine, permitindo a execução de um mesmo arquivo semi-interpretado em Java em

diversas plataformas, incluindo, por exemplo, os Sistemas Operacionais Linux e o

Windows, e diversos Sistemas embarcados, já para o código em C++ é necessário que

ele seja compilado por compiladores específicos de cada Sistema Operacional para que

possa funcionar em diversas plataformas.

15

3. REFERÊNCIAS

Fedora 12. Sistema Operacional baseado em Linux. Disponível em:

<http://fedoraproject.org/pt/>. Acesso em 10 mar 2010.

GCC. GNU Compiler Collection. Disponível em: <http://gcc.gnu.org/>. Acesso em 15

mar 2010.

Sun Virtual Box. Software da Sun que permite simular um sistema operacional através

da virtualização. Disponível em: <http://www.virtualbox.org/>. Acesso em 10 mar

2010.

JDK. Java Development Kit. Disponível em:

<http://java.sun.com/javase/downloads/index.jsp>. Acesso em 10 mar 2010.

Perf Linux - Comparação entre Java e C++

Documents