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: [email protected]
Date: Mon, 23 Apr 2012 18:31:45 -0300
To: [email protected]
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 <[email protected]> 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: [email protected]
Date: Mon, 23 Apr 2012 14:14:41 -0300
To: [email protected]
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
[email protected]
http://mail.pm.org/mailman/listinfo/rio-pm
_______________________________________________
Rio-pm mailing list
[email protected]
http://mail.pm.org/mailman/listinfo/rio-pm
_______________________________________________
Rio-pm mailing list
[email protected]
http://mail.pm.org/mailman/listinfo/rio-pm
_______________________________________________
Rio-pm mailing list
[email protected]
http://mail.pm.org/mailman/listinfo/rio-pm
