Buenas,
recientemente, tratando de resolver las dudas de un principiante en Perl, he podido volver a constatar la dificultad que suponen para los novatos los vectores (@
arrays) y las tablas asociativas (
%hashes). Sin embargo, estas estructuras de datos son muy empleadas por usuarios experimentados, puesto que permiten guardar y modelar datos complejos de manera relativamente sencilla. No obstante, después de tanto tiempo usando estas estructuras, creo que nunca me he puesto a medir el coste de un vector y de un
hash para guardar los mismos datos en un programita Perl. Este coste es especialmente relevante para manejar volúmenes de datos grandes, como averiguaremos con ayuda de los módulos
Benchmark y
Devel::Size.
Si además invocamos el módulo
GraphViz::Data::Grapher, podremos dibujar ambos tipos de estructuras de datos, lo cual puede ayudar a los más principiantes:
#!/usr/bin/perl -w
use strict;
use Benchmark;
use Devel::Size;
use Scalar::Util;
#use GraphViz::Data::Grapher;
my $MUESTRAS = 100;
# 1) mide tiempo de creacion de estructura de datos
print "# construyendo estructuras de datos:\n";
print "> hash :\n";
timethis( $MUESTRAS, "crea_estructura_datos('hash')" );
print "> array:\n";
timethis( $MUESTRAS, "crea_estructura_datos('array')" );
# 2) mide memoria que necesita cada estructura
print "\n# memoria RAM usada (KB):\n";
my $ref_hash = crea_estructura_datos('hash');
printf("\n> hash: %1.1f\n",
Devel::Size::total_size($ref_hash)/1024);
my $ref_array = crea_estructura_datos('array');
printf("> array: %1.1f\n",
Devel::Size::total_size($ref_array)/1024);
# 3) mide tiempo de consulta de estructura de datos
print "\n# consultando estructuras de datos:\n";
print "> hash:\n";
timethis( $MUESTRAS, sub{ consulta_estructura_datos($ref_hash) } );
print "> array:\n";
timethis( $MUESTRAS, sub{ consulta_estructura_datos($ref_array) } );
############################################
sub crea_estructura_datos
{
my ($hash_o_array) = @_;
my $referencia;
if($hash_o_array eq 'hash')
{
foreach my $n (1..100_000)
{
# las llaves ocupan menos como cadenas de caracteres
# http://codenode.com/perl-memory-usage
$referencia->{"$n"} = $n * 10; #7165.6KB en CPU 64bits
#$referencia->{sprintf("%01.3f",$n)} = $n * 10; #7556.2KB "
#$referencia->{$n/0.3} = $n * 10; #7914.3KB "
}
#descomenta para generar grafo de estructura como el del blog
# OJO: mejor que sea una estructura no muy grande
#my $grafo = GraphViz::Data::Grapher->new($referencia);
#print $grafo->as_png("hash.png");
}
else
{
foreach my $n (1..100_000)
{
push(@{$referencia}, $n * 10); # 3367.9KB
#$referencia->[$n-1] = $n * 10; # lo mismo
}
#my $grafo = GraphViz::Data::Grapher->new($referencia);
#print $grafo->as_png("array.png");
}
return $referencia;
}
sub consulta_estructura_datos
{
my ($referencia) = @_;
my $index;
if(Scalar::Util::reftype($referencia) eq "HASH")
{
foreach my $n (1..100_000)
{
$index = int(rand(100_000));
$referencia->{$index} += 1;
}
}
else
{
foreach my $n (1..100_000)
{
$index = int(rand(100_000));
$referencia->[$index] += 1;
}
}
return $referencia;
}
Mediante este código, ejecutado en mi máquina de 64 bits, podemos ver que
un hash sencillo ocupa un poco más del doble que un array para guardar una lista de enteros, y que
su tamaño varía según el tipo de llave que usemos. Además,
tardamos el triple de tiempo en llenar el hash que el array equivalente. Finalmente, este pequeño experimento muestra que
el acceso y modificación de datos dentro un hash es al menos dos veces más lento que en un array:
# construyendo estructuras de datos:
> hash :
timethis 100: 10 wallclock secs (10.45 usr + 0.01 sys = 10.46 CPU) @ 9.56/s (n=100)
> array:
timethis 100: 3 wallclock secs ( 2.17 usr + 0.00 sys = 2.17 CPU) @ 46.08/s (n=100)
# memoria RAM usada (KB):
> hash: 7165.6
> array: 3367.9
# consultando estructuras de datos:
> hash:
timethis 100: 6 wallclock secs ( 6.08 usr + 0.01 sys = 6.09 CPU) @ 16.42/s (n=100)
> array:
timethis 100: 3 wallclock secs ( 2.61 usr + 0.00 sys = 2.61 CPU) @ 38.31/s (n=100)
Un saludo,
Bruno
