Re^3: hash interface

The cost depends a great deal on what you do with the argument list inside the sub/method. If you don't copy the argument list in some fashion then the hash construction can be expensive for more than a few parameters. However if you would otherwise copy the argument list into an array or hash inside the sub, the cost of constructing the hash is much less relevant. Consider:

use strict;
use warnings;
use Benchmark qw(cmpthese);

for my $argCount (2, 10, 100) {
    my @args = (1 .. $argCount);

    print "\nFor $argCount elements:\n";

    cmpthese (-1, {
            hashArg => sub {noCopy ({@args})},
            listArg => sub {noCopy (@args)},
            toList => sub {toList (@args)},
            toHash => sub {toHash (@args)},
        }
    );
}


sub noCopy {
}


sub toList {
    my @args = @_;
}


sub toHash {
    my %hash = @_;
}
[download]

Prints:


For 2 elements:
             Rate hashArg  toList  toHash listArg
hashArg 1066864/s      --    -12%    -27%    -74%
toList  1205941/s     13%      --    -17%    -71%
toHash  1459027/s     37%     21%      --    -64%
listArg 4106796/s    285%    241%    181%      --

For 10 elements:
             Rate  toList hashArg  toHash listArg
toList   344656/s      --    -14%    -17%    -91%
hashArg  399964/s     16%      --     -4%    -90%
toHash   416260/s     21%      4%      --    -89%
listArg 3846573/s   1016%    862%    824%      --

For 100 elements:
             Rate hashArg  toHash  toList listArg
hashArg   38850/s      --     -6%     -7%    -98%
toHash    41541/s      7%      --     -1%    -98%
toList    41895/s      8%      1%      --    -98%
listArg 1686904/s   4242%   3961%   3926%      --
[download]

True laziness is hard work

Comment on Re^3: hash interface Select or Download Code

Replies are listed 'Best First'.
Re^4: hash interface by shmem (Chancellor) on Mar 06, 2009 at 11:14 UTC
Your benchmarks support my point. But there are two subs missing - assignment of a passed hash reference to a scalar and to a hash: use strict; use warnings; use Benchmark qw(cmpthese); for my $argCount (2, 10, 100) { my @args = (1 .. $argCount); print "\nFor $argCount elements:\n"; cmpthese (-1, { hashArg => sub { noCopy ({@args}) }, listArg => sub { noCopy ( @args) }, toList => sub { toList ( @args) }, toHash => sub { toHash ( @args) }, rtoHref => sub { rtoHref ({@args}) }, rtoHash => sub { rtoHash ({@args}) }, } ); } sub noCopy { } sub toList { my @args = @_ } sub toHash { my %hash = @_ } sub rtoHash { my %hash = %{$_[0]} } sub rtoHref { my ($hash) = @_ } [download] which yields For 2 elements: Rate rtoHash rtoHref hashArg toList toHash listArg rtoHash 455110/s -- -35% -48% -49% -50% -82% rtoHref 695078/s 53% -- -21% -23% -24% -72% hashArg 877714/s 93% 26% -- -2% -4% -65% toList 899514/s 98% 29% 2% -- -2% -64% toHash 918729/s 102% 32% 5% 2% -- -63% listArg 2513115/s 452% 262% 186% 179% 174% -- For 10 elements: Rate rtoHash rtoHref toList toHash hashArg listArg rtoHash 166131/s -- -49% -51% -54% -54% -93% rtoHref 324588/s 95% -- -5% -10% -11% -86% toList 342024/s 106% 5% -- -5% -6% -85% toHash 360654/s 117% 11% 5% -- -1% -84% hashArg 364089/s 119% 12% 6% 1% -- -84% listArg 2271050/s 1267% 600% 564% 530% 524% -- For 100 elements: Rate rtoHash rtoHref hashArg toList toHash listArg rtoHash 18862/s -- -49% -54% -55% -55% -98% rtoHref 36885/s 96% -- -10% -13% -13% -96% hashArg 40959/s 117% 11% -- -3% -3% -96% toList 42164/s 124% 14% 3% -- -0% -96% toHash 42347/s 125% 15% 3% 0% -- -96% listArg 1037900/s 5403% 2714% 2434% 2362% 2351% -- [download] which shows that constructing a hash reference from the argument list and actually using it is always slowest; passing a plain list is fastest.	[reply] [d/l] [select]

Replies are listed 'Best First'.

Re^4: hash interface
by shmem (Chancellor) on Mar 06, 2009 at 11:14 UTC

Your benchmarks support my point. But there are two subs missing - assignment of a passed hash reference to a scalar and to a hash:

use strict;
use warnings;
use Benchmark qw(cmpthese);

for my $argCount (2, 10, 100) {
    my @args = (1 .. $argCount);

    print "\nFor $argCount elements:\n";

    cmpthese (-1, {
            hashArg => sub { noCopy  ({@args}) },
            listArg => sub { noCopy  ( @args)  },
            toList  => sub { toList  ( @args)  },
            toHash  => sub { toHash  ( @args)  },
            rtoHref => sub { rtoHref ({@args}) },
            rtoHash => sub { rtoHash ({@args}) },
        }
    );
}


sub noCopy  {                     }
sub toList  { my @args = @_       }
sub toHash  { my %hash = @_       }
sub rtoHash { my %hash = %{$_[0]} }
sub rtoHref { my ($hash) = @_     }
[download]

which yields

For 2 elements:
             Rate rtoHash rtoHref hashArg  toList  toHash listArg
rtoHash  455110/s      --    -35%    -48%    -49%    -50%    -82%
rtoHref  695078/s     53%      --    -21%    -23%    -24%    -72%
hashArg  877714/s     93%     26%      --     -2%     -4%    -65%
toList   899514/s     98%     29%      2%      --     -2%    -64%
toHash   918729/s    102%     32%      5%      2%      --    -63%
listArg 2513115/s    452%    262%    186%    179%    174%      --

For 10 elements:
             Rate rtoHash rtoHref  toList  toHash hashArg listArg
rtoHash  166131/s      --    -49%    -51%    -54%    -54%    -93%
rtoHref  324588/s     95%      --     -5%    -10%    -11%    -86%
toList   342024/s    106%      5%      --     -5%     -6%    -85%
toHash   360654/s    117%     11%      5%      --     -1%    -84%
hashArg  364089/s    119%     12%      6%      1%      --    -84%
listArg 2271050/s   1267%    600%    564%    530%    524%      --

For 100 elements:
             Rate rtoHash rtoHref hashArg  toList  toHash listArg
rtoHash   18862/s      --    -49%    -54%    -55%    -55%    -98%
rtoHref   36885/s     96%      --    -10%    -13%    -13%    -96%
hashArg   40959/s    117%     11%      --     -3%     -3%    -96%
toList    42164/s    124%     14%      3%      --     -0%    -96%
toHash    42347/s    125%     15%      3%      0%      --    -96%
listArg 1037900/s   5403%   2714%   2434%   2362%   2351%      --
[download]

which shows that constructing a hash reference from the argument list and actually using it is always slowest; passing a plain list is fastest.

[reply]
[d/l]
[select]