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

Terça Abril 24 16:07:46 PDT 2012

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: creaktive em gmail.com
Date: Mon, 23 Apr 2012 18:31:45 -0300
To: rio-pm em 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_1000 em 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: creaktive em gmail.com

Date: Mon, 23 Apr 2012 14:14:41 -0300
To: rio-pm em 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 em pm.org
http://mail.pm.org/mailman/listinfo/rio-pm 		 	   		  

_______________________________________________

Rio-pm mailing list

Rio-pm em pm.org

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

_______________________________________________
Rio-pm mailing list
Rio-pm em pm.org
http://mail.pm.org/mailman/listinfo/rio-pm 		 	   		  
-------------- Próxima Parte ----------
Um anexo em HTML foi limpo...
URL: <http://mail.pm.org/pipermail/rio-pm/attachments/20120424/0779416a/attachment-0001.html>