Re: [Rio-pm] benchmark (era: Perl em desuso??)

Aureliano Guedes Tue, 24 Apr 2012 16:07:57 -0700

Lembrei de dois codigos agora bem interessantes:

C
#################################################
#include <stdio.h>
#include <windows.h>
 typedef long long int64;
 int main()
{
    int64 Frequency = 0;
    int64 CounterOne = 0;
 int64 CounterTwo = 0;
 int64 CounterTree = 0;


    double CounterAverage = 0;



    int64 Current = 0;
 int64 Previus = 0;
 int64 Next = 0;



    int Count = 0;


    
QueryPerformanceFrequency(&Frequency);



    printf("Frequency: %lld\n", Frequency);



    QueryPerformanceCounter(&CounterOne);
 QueryPerformanceCounter(&CounterTwo);
 QueryPerformanceCounter(&CounterTree);


    
printf("CounterOne: %lld\n", CounterOne);

    printf("CounterTwo: %lld\n", CounterTwo);
    
printf("CounterTree: %lld\n", CounterTree);


    
printf("Call Counter Interval: %lld\n", CounterOne - CounterTree);
    
printf("Miliseconds: %llf\n", ((double)CounterOne - (double)CounterTree) / 
((double)Frequency / 1000.0f));
 CounterAverage = ((double)CounterOne - (double)CounterTree) / 3.0f;
    printf("Counter Average: %llf\n", CounterAverage);



    printf("====================\n");
    
Current = 1;


    QueryPerformanceCounter(&CounterOne);



    while(!(Count == 100))
    {
 Next = (Current + Previus);
 Previus = Current;
        
Current = Next;
        
Count = Count + 1;
 }


    
QueryPerformanceCounter(&CounterTwo);
 printf("Result: %lld\n", Current);
    
printf("CounterOne: %lld\n", CounterOne);

    printf("CounterTwo: %lld\n", CounterTwo);

    printf("Counter Interval: %lld\n", CounterTwo - CounterOne);
 printf("Miliseconds: %lld\n", (CounterTwo - CounterOne) / (Frequency / 1000));

    printf("Final (Counter Interval - (Call Counter Average * 2)): %llf\n", 
(((double)CounterTwo - (double)CounterOne) - (CounterAverage * 2)));


    return(0);
}
####################################################################################

Perl
################################################################################
#!/usr/bin/perl -w

use Win32::kernel32;
use strict;
use warnings


my $Frequency = 0;
my $CounterOne = 0;
my $CounterTwo = 0;
my $CounterTree = 0;


my $CounterAverage = 0.0;


my $Current = 0;
my $Previus = 0;
my $Next = 0;

my $Count = 0;

$Frequency = Win32::QueryPerformanceFrequency();



print "Frequency: ", $Frequency, "\n";


$CounterOne = Win32::QueryPerformanceCounter();
$CounterTwo = Win32::QueryPerformanceCounter();
$CounterTree = Win32::QueryPerformanceCounter();


print "CounterOne: ", $CounterOne, "\n";
print "CounterTwo: ", $CounterTwo, "\n";
print "CounterTree: ", $CounterTree, "\n";


print "Call Counter Interval: ", $CounterTree - $CounterOne, "\n";
print "Miliseconds: ", ($CounterTree - $CounterOne) / ($Frequency / 1000), "\n";


$CounterAverage = ($CounterTree - $CounterOne) / 3;
print "Counter Average: ", $CounterAverage, "\n";


print "====================\n";
$Current = 1;


$CounterOne = Win32::QueryPerformanceCounter();


while(!($Count == 100))
{
    $Next = ($Current + $Previus);
    $Previus = $Current;
    $Current = $Next;
    $Count = $Count + 1;
}


$CounterTwo = Win32::QueryPerformanceCounter();


print("Result: ", $Current, "\n");
print("CounterOne: ", $CounterOne, "\n");
print("CounterTwo: ", $CounterTwo, "\n");
print("Counter Interval: ", $CounterTwo - $CounterOne, "\n");
print("Miliseconds: ", ($CounterTwo - $CounterOne) / ($Frequency / 1000), "\n");
print("Final (Counter Interval - (Call Counter Average * 2)): ", (($CounterTwo 
- $CounterOne) - ($CounterAverage * 2)), "\n");
#######################################################################################





From: creakt...@gmail.com
Date: Mon, 23 Apr 2012 18:31:45 -0300
To: rio-pm@pm.org
Subject: Re: [Rio-pm] benchmark (era: Perl em desuso??)

Aureliano, esse algoritmo, apesar de servir para listar números primos, quase 
não faz cálculo. Veja:

    for my $i (2 .. sqrt($n)) {

        if ($nums[$i]) {

            for (my $m = $i ** 2; $m <= $n; $m += $i) {

                $nums[$m] = 0;

            }

        }

    }


Para encontrar todos os primos de 0 a 100 milhões, a conta mais "pesada" será 
elevar um número ao quadrado menos de 10 mil vezes. Convenhamos, isso é 
irrisório. Já a atribuição de $nums[$m]... Vai acontecer 240 milhões de vezes!

Bom, acontece que, nas principais linguagens dinâmicas, o protótipo do array é 
lista. E lista não é muito boa para acesso por índice. A do Perl, por exemplo, 
fritaria uns 30 GB de RAM, pela minha estimativa. Dá para acoxambrar array de 
bits num scalar, mas aí passa pela outra abstração, e, apesar de ficar mais 
enxuto, fica bem mais lento.

Já em C (simplificando), protótipo de tudo é byte. Quer "marcar" alguma posição 
num array de bits? Fácil:


#define SetBit(a, b) (((char *) a)[(b) >> 3] |= (1 << ((b) & 7)))


Essa nhaca compila em um código de máquina minúsculo que roda 240 milhões de 
vezes em frações de segundo.Linguagens dinâmicas (geralmente) não podem acessar 
a memória diretamente, precisam das camadas de abstração (e isso é BOM).


ABS()




On Mon, Apr 23, 2012 at 17:09, Aureliano Guedes <guedes_1...@hotmail.com> wrote:






Lembrando que Python é uma linguagem com suporte nativo a operações matematicas 
melhor que Perl.
O desempenho para executar calculos provavelmente seja realmente maior, mas 
estava pensando, e outras operações como


socket ou mesmo parsea um texto??
Sei que alguns vão responder: "mas o processador entende tudo como calculo", 
mas acho que a linguagem focar em determinado ponto
pode ser que dependendo da operação matematica (a nivel de processador) o 
desempenho da linguagem tambem mude.


Um exemplo disso é comparar o laço for e o laço while, posso fazer um contador 
com os dois, mas eles trabalham de forma diferentes no processador.

From: creakt...@gmail.com


Date: Mon, 23 Apr 2012 14:14:41 -0300
To: rio-pm@pm.org
Subject: [Rio-pm] benchmark (era: Perl em desuso??)

Coincidentemente, Junior Moraes (fvox) me mostrou benchmark de Perl VS Ruby 
utilizando o algoritmo do Crivo de Eratóstenes... Ele pegou um algoritmo 
mal-implementado em Ruby e traduziu para Perl (como parte do desafio), e, ainda 
assim, em Perl tinha ficado MUITO mais rápido.



Então usei como referência http://rosettacode.org/wiki/Sieve_of_Eratosthenes, e 
escolhi os as implementações mais parecidas entre si (e que não envolviam 
otimizações "hardcore"): https://gist.github.com/2413936



Seguem os resultados:
C: 0.09user 0.00system 0:00.09elapsed 98%CPU (0avgtext+0avgdata 
11872maxresident)kPython: 3.63user 0.10system 0:03.77elapsed 99%CPU 
(0avgtext+0avgdata 1270288maxresident)k



Perl (usando array): 7.14user 0.44system 0:07.67elapsed 98%CPU 
(0avgtext+0avgdata 6092432maxresident)kPerl (usando bit vector): 12.47user 
0.02system 0:12.53elapsed 99%CPU (0avgtext+0avgdata 202496maxresident)k



Ruby: 13.25user 0.08system 0:13.44elapsed 99%CPU (0avgtext+0avgdata 
1300304maxresident)k
ABS()


_______________________________________________
Rio-pm mailing list
Rio-pm@pm.org
http://mail.pm.org/mailman/listinfo/rio-pm                                      
  

_______________________________________________

Rio-pm mailing list

Rio-pm@pm.org

http://mail.pm.org/mailman/listinfo/rio-pm



_______________________________________________
Rio-pm mailing list
Rio-pm@pm.org
http://mail.pm.org/mailman/listinfo/rio-pm

_______________________________________________
Rio-pm mailing list
Rio-pm@pm.org
http://mail.pm.org/mailman/listinfo/rio-pm

Re: [Rio-pm] benchmark (era: Perl em desuso??)

Reply via email to