Hay casos en que sería muy importante saber cuánto usa cada variable en Perl. Para esto el módulo Devel::Size ofrece dos funciones. Tanto en size como total_size aceptan una referencia a una variable o una estructura de datos. La diferencia entre ellos es que en las estructuras de datos complejas (aka. arrays y hashes), size sólo devuelve la memoria utilizada por la estructura, no por los datos.

Hay que señalar algunas diferencias entre la memoria que Perl solicita, a lo que Devel::Size informe, y lo que en realidad ha asignado el sistema operativo. Si está interesado, hay una buena explicación en la documentación de Devel::Size

El siguiente script intenta mostrar algunos valores básicos: 

use strict;
use warnings;
use 5.010;

use Devel::Size qw(size total_size);

my $x;
my @y;
my %z;

say '                           size  total_size';
both('SCALAR', \$x);        #    24    24
both('ARRAY',  \@y);        #    64    64
both('HASH',   \%z);        #   120   120
both('CODE', sub {} );      #  8452  8452
say '';

both('SCALAR', \$x);        #  24    24
$x = 'x';
both('SCALAR-1', \$x);      #  56    56
$x = 'x' x 15;
both('SCALAR-15', \$x);     #  56    56
$x = 'x' x 16;
both('SCALAR-16', \$x);     #  72    72
$x = 'x' x 31;
both('SCALAR-31', \$x);     #  72    72
$x = 'x' x 32;
both('SCALAR-32', \$x);     #  88    88
$x = '';
both('SCALAR=""', \$x);     #  88    88
$x = undef;
both('SCALAR=undef', \$x);  #  88    88
undef $x;
both('undef SCALAR', \$x);  #  40    40
say '';

both('ARRAY',  \@y);               #    64    64
@y = ('x');
both('ARRAY-1', \@y);              #    96   152
@y = ('x' x 15);
both('ARRAY-15', \@y);             #    96   152
@y = ('x' x 16);
both('ARRAY-16', \@y);             #    96   168
@y = ('x' x 31);
both('ARRAY-31', \@y);             #    96   168
@y = ('x' x 32);
both('ARRAY-32', \@y);             #    96   184
@y = ('x') x 2;
both('ARRAY-1-1', \@y);            #    96   208
@y = ('x') x 4;
both('ARRAY-1-1-1-1', \@y);        #    96   320
@y = ('x') x 5;
both('ARRAY-1-1-1-1-1', \@y);      #   104   384
@y = ('x') x 6;
both('ARRAY-1-1-1-1-1-1', \@y);    #   112   448
@y = ('x') x 7;
both('ARRAY-1-1-1-1-1-1-1', \@y);  #   128   520
@y = ();
both('ARRAY = ()', \@y);           #   128   128
undef @y;
both('undef ARRAY', \@y);          #    64    64
say('');

both('HASH',   \%z);                       #  120   120
%z = ('x' => undef);
both('HASH x => undef',   \%z);            #  179   203
%z = ('x' => "x");
both('HASH x => "x"',   \%z);              #  179   235
%z = ('x' x 10 => "x" x 20);
both('HASH "x" x 10 => "x" x 20',   \%z);  #  188   260
for my $c (qw(a b c d e f g h i)) {
    $z{$c x 10} = $c x 20;
}
both('HASH 10 * 10 + 10 * 20',   \%z);     #  864  1584
%z = ();
both('HASH=()',   \%z);                    #  184   184
undef %z;
both('undef HASH',   \%z);                 #  120   120
my $o = bless \%z,'Some::Very::Long::Class::Name::That::Probably::Noone::Uses';
both('blessed HASH', $o);                  #  120   120
say('');

both('CODE', sub {}  );                   #  8516  8516
both('CODE2', sub { my $w }  );           #  8612  8612
both('CODE3', sub { my $w = 'a' }  );     #  8820  8820

sub both {
    my ($name, $ref) = @_;
    printf "%-25s %5d %5d\n", $name, size($ref), total_size($ref);
}

El ambiente

Estos resultados fueron generados sobre 64 bit OSX, ejecutando perl 5.18.2 usando Devel::Size 0.79. (Obtuve el mismo resultado cuando ejecuté el escript sobre 5.18.1, excepto que los valores para el CODE'references fueron de 8 bytes mas pequeños).

Algunas observaciones

El tamaño del código-referencias parece enorme. Me pregunto si estos números son correctos.

Extrañamente bless no cambia el tamaño de la referencia. O por lo menos, no se divulga.

Se asigna memoria en trozos de 16 bytes para cadens. Por lo tanto es la memoria utilizada por una larga cadena de caracteres 1 el mismo que utiliza por una larga cadena de 15 caracteres.

Ni ajustar la cadena a la cadena vacía ($x = '';), ni asignar undef a él ($x = undef;) reduce el uso de la memoria. Tuve que llamar undef $x; por eso. Incluso entonces volvió sólo a 40, en lugar de la original 24.

En matrices, cada elemento utiliza 8 bytes + memoria asignada para el contenedor escalar + los datos.

Ajuste @y = (); eliminar la asignación de memoria de la fecha (o por lo menos total_size no se muestra nada más) Llamando undef @y; también libera la memoria asignada a la estructura.

En hashes es aún más complejo. No intento describirlo. La documentación de Devel::Size tiene alguna explicación.

El resultado actual se observa algo como esto

                          size    total_size
SCALAR                       24    24
ARRAY                        64    64
HASH                        120   120
CODE                       8452  8452

SCALAR                       24    24
SCALAR-1                     56    56
SCALAR-15                    56    56
SCALAR-16                    72    72
SCALAR-31                    72    72
SCALAR-32                    88    88
SCALAR=""                    88    88
SCALAR=undef                 88    88
undef SCALAR                 40    40

ARRAY                        64    64
ARRAY-1                      96   152
ARRAY-15                     96   152
ARRAY-16                     96   168
ARRAY-31                     96   168
ARRAY-32                     96   184
ARRAY-1-1                    96   208
ARRAY-1-1-1-1                96   320
ARRAY-1-1-1-1-1             104   384
ARRAY-1-1-1-1-1-1           112   448
ARRAY-1-1-1-1-1-1-1         128   520
ARRAY = ()                  128   128
undef ARRAY                  64    64

HASH                        120   120
HASH x => undef             179   203
HASH x => "x"               179   235
HASH "x" x 10 => "x" x 20   188   260
HASH 10 * 10 + 10 * 20      864  1584
HASH=()                     184   184
undef HASH                  120   120
blessed HASH                120   120

CODE                       8516  8516
CODE2                      8612  8612
CODE3                      8820  8820