[ruby-it] Quattro interpreti ruby a confronto

[Paolo Montrasio]

Ciao Marco,

nel codice misurato dal mio benchmark avevo deciso di includere anche 
Array.<< perché ritenevo che l'inizializzazione dell'array fosse parte 
integrante dell'operazione di concatenazione.

Sia con l'array che con (ad esempio) String.+ si parte con delle 
stringhe e poi c'è l'operazione da misurare che per String.+ è 
semplicemente farne la somma mentre nell'altro caso si deve mettere le 
stringhe in un array e farne una join.
Dal mio punto di vista saltare l'inizializzazione dell'array favoriva 
indebitamente Array.join rispetto agli altri metodi.

Fortunamente non è questione di punti di vista, altrimenti potremmo 
discuterne per l'eternità, ma di come saranno fatte le nostre 
applicazioni reali. Se le stringhe con cui lavoreremo sono già in un 
array, dal tuo benchmark sappiamo che la join è sicuramente preferibile 
a a[0]+a[1]+etc. Se non sono in un array, dal mio benchmark sappiamo che 
per stringhe piccole conviene usare la concatenazione e non crearsi 
l'array per farne la join.

In sostanza avevamo pensato a due scenari differenti e quindi abbiamo 
ragione tutti e due :-)

Riporto infine i risultati del tuo benchmark sul mio pc che come cpu è 
identico al tuo. Ho più RAM (ma durante il benchmark ho sempre avuto 
liberi almeno 1.8 GB), un OS differente (Ubuntu 8.10 64 bit) e ruby 
1.8.7.

                           user     system      total        real
1.000.000 iterations:
'1000'.create:
'%01000d' % 0          3.560000   0.190000   3.750000 (  3.753813)
0 * 1000               9.760000   0.110000   9.870000 ( 10.004395)
'4000'.create:
'%04000d' % 0          7.040000   0.190000   7.230000 (  7.247626)
0 * 4000              37.950000   4.840000  42.790000 ( 42.877476)
1000: str vs [].join:
+                     23.570000   0.560000  24.130000 ( 24.184767)
#{}                   10.160000   0.190000  10.350000 ( 10.368516)
<<                    13.550000   0.180000  13.730000 ( 13.752579)
[].join                4.620000   0.750000   5.370000 (  5.412506)
--- Total:            76.480000   6.260000  82.740000 ( 83.048395)

Da me gira in 76 s contro 100 s da te. Mi chiedo se la differenza sia 
dovuta alla versione di ruby o a come sono stati compilati gli 
interpreti per Windows e per Linux. Non credo che l'OS c'entri in 
qualche modo dato che stiamo misurando operazioni CPU bound. Da quel che 
ho googlato non c'è accordo se la 1.8.6 sia più o meno veloce della 
1.8.7. Quel che so è che apparentemente su Linux conviene compilarsi 
l'interprete, cosa che faccio in produzione ma non sul mio pc di 
sviluppo dove ho fatto girare il benchmark. Secondo 
http://antoniocangiano.com/2008/12/10/reflections-on-the-ruby-shootout/ 
si ottiene un raddoppio di velocità.

Paolo
-- 
Posted via http://www.ruby-forum.com/.