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

1
 Í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

2
 Í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

3
 ÍNDICES DE GRÁFICOS

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

4
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

5
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++

6
 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

7
à 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++

8
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.

9
 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

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

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.

10
 #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.

11
 Tipos de Códigos C++ Java

Tempo de Execução 0,01067 0,23132341

Tarefas de Relógio 9,39 178,70

Trocas de Contexto 1 157,66

Migração de CPU 0 0

Faltas de Página 234 2862

Ciclos 0 0

Instruções 0 0

Referências à cache 0 0

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

Tipos de Códigos C++ Java

Tempo de Execução 0,016125086 0,31627957

Tarefas de Relógio 13,97 201,09

Trocas de Contexto 2 295,33

Migração de CPU 0 0

Faltas de Página 352 2910

Ciclos 0 0

Instruções 0 0

Referências à cache 0 0

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

12
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.

13
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.

14
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.

15