[SP-pm] Duvida primaria

[russoz at gmail.com]

2010/10/20 Nilson Santos Figueiredo Jr. <acid06 em gmail.com>
[...]

>
> Usar given/when é *MUITO* mais rápido do que usar uma dispatch table,
> por exemplo. E mesmo um lookup burro, ao invés de dispatch pra uma
> função anônima ainda é 3x mais lento.
>
> Exemplo de resultados de benchmark:
>
>              Rate dispatch   lookup   switch
> dispatch  121116/s       --     -77%     -92%
> lookup    524558/s     333%       --     -67%
> switch   1599278/s    1220%     205%       --
>

Nilson,

Acho que a contundência da sua afirmação não condiz com a simplicidade do
script que você apresentou.

Eu fiz algumas modificações no seu script para: 1) não declarar as tabelas
de dispatch DENTRO da função a ser testada, apenas uma vez, do lado de fora,
e 2) diferenciei lookup/dispatch em hash e em array.

Os resultados são bem diferentes:

19:14:32 BRST az em blueturtle:~/tmp/perldev $ ./test-case.pl
                    Rate dispatch_hash switch dispatch_array lookup_hash
lookup_array
dispatch_hash  1088180/s            --    -5%           -10%        -52%
    -58%
switch         1147749/s            5%     --            -6%        -49%
    -56%
dispatch_array 1215036/s           12%     6%             --        -46%
    -53%
lookup_hash    2265153/s          108%    97%            86%          --
    -13%
lookup_array   2591771/s          138%   126%           113%         14%
      --

Código em:
http://pastebin.org/341050

Código segue abaixo (óbvio que o exemplo é simplista e se aumentar o
> númerp de cláusulas do switch vai ficando cada vez mais lento, mas
> ainda deve ser mais rápido pra muitos cases):
>

No caso dos dispatches, você estava compilando código dinamicamente a cada
chamada da função => claro que será mais lento.
No caso do lookup (em hash) você estava invocando uma função de hash 3 vezes
para cada chamada da função de teste => claro que será mais lento.

Uma construção switch/case (aka given/when) irá se tornar, em qualquer
binário que você usar, em uma sequência de saltos condicionais, até que
enfim haja a execução do caso desejado, enquanto que uma tabela de lookup é
sempre uma soma e mais a execução, constante.

Também usando switch/case, quando o número de casos é muito grande, pode
haver um efeito colateral no desempenho: a ordem dos casos passa a ser
significantiva na performance, pois nessa construção, o último caso só é
testado após TODOS OS OUTROS serem testados.

Assim, lookup simples será sempre mais rápido, na média, que qualquer outro
caso - tanto que é isso que se usa em kernel, por exemplo. No meu teste o
dispatch baseado em array foi até mesmo mais rápido que o switch, que foi
pouco mais rápido que o dispatch baseado em hash, mas vamos considerar que
estejam "tecnicamente empatados" como gosta de afirmar o ibope. Nesse caso,
abro mão da chatice otimizadora e reforço o e-mail do Eden: é por conta de
legibilidade/extensibilidade.

A minha conclusão é: se há uma necessidade muito grande de performance, faça
tabelas de lookup de valores baseadas em array. Se você quer ter um código
extensível e legível, faça dispatch - use hash mesmo que fica mais fácil de
ler ;-) switch? sei lá, só se no seu estilo de programar você fizer questão
disso.

Some $0.02 * rand 3 cents

-- 
Alexei Znamensky [russoz_gmail_com] [russoz.wordpress.com] [
www.flickr.com/photos/alexeiz]
«Only love / Can bring the rain / That makes you yearn to the sky»
-------------- Pr�xima Parte ----------
Um anexo em HTML foi limpo...
URL: <http://mail.pm.org/pipermail/saopaulo-pm/attachments/20101020/cfa72201/attachment-0001.html>