使用散列和散列引用的Perl速度比较

Question

I am rying to compare if it is better to use hashes or reference to hashes, hash ref as I understand just a pointer to the hash itself, so I thought should be no speed difference.

I did a basic benchmark and I found the hash refs are slower than using the hash direct by average 20-27%.

Here is the basic benchmark code I used:

use Benchmark qw(:all);

cmpthese(10_000_000, {
    hash            =>  sub { my %hash = (); },
    hashref =>  sub { my $hahref = {}; }
});

cmpthese(10_000_000, {
    hash            =>  sub {
                                    my %hash;
                                    $hash{fname}="first name";
                                    $hash{mname}="middle name";
                                    $hash{lname}="last name";
                                },

    hashref =>  sub {
                                    my $hahref;
                                    $hahref->{fname}="first name"; 
                                    $hahref->{mname}="middle name";
                                    $hahref->{lname}="last name"; 
                                },

    hashrefs    =>  sub {
                                    my $hahref;
                                    $$hahref{fname}="first name"; 
                                    $$hahref{mname}="middle name";
                                    $$hahref{lname}="last name"; 
                                },
});

and here is the benchmark results on laptop dell, windows 8, core i7, 16MB RAM:

             Rate hashref    hash
hashref 5045409/s      --    -17%
hash    6045949/s     20%      --

             Rate hashrefs  hashref     hash
hashrefs 615764/s       --      -2%     -21%
hashref  625978/s       2%       --     -19%
hash     775134/s      26%      24%       --

Output completed (1 min 6 sec consumed)

My question is, if my benchmark is correct and the hash refs are so slow, why most modules like DBI use hash refs to return results. Also most modules accepts hash refs not hashes for arguments and also return hash refs and not hashes.

Answer 1

Hashes are faster to access elements from; hashrefs are faster to pass as arguments to a function, or return as the result of a function. This makes sense if you think about it:

• A hashref is basically a pointer to a hash, so when Perl sees $href->{xyz} , it needs to follow the pointer to find the hash, and then find element xyz in the hash. When Perl sees $hash{xyz} it doesn't need to do that initial pointer-following bit; it can find element xyz straight away.

• Hashes cannot be directly passed to or from subs; they need to be flattened into a list of scalars. If a hash has, say four keys and four values, then passing it to a sub means passing a list of eight scalars to the function. Inside the function, you'll probably have something like my %args = @_ which copies those eight scalars into a new hash. Lots of work to be done. Passing a hashref is just a matter of passing a single scalar, so it's faster.

Mostly this is micro-optimization, and you should just choose whichever data structure makes the most sense for your program. However for those occasions when you really need to eke out every bit of speed you can, it is possible to have the best of both worlds...

Let's say you have a function which needs to accept a hash (or maybe a hashref; you haven't decided yet) and needs to add up some of the keys. Here are your original two options:

sub add_hash {
    my %hash = @_;
    return $hash{foo} + $hash{bar} + $hash{baz};
}

sub add_hashref {
    my ($href) = @_;                                    # faster than add_hash
    return $href->{foo} + $href->{bar} + $href->{baz};  # slower than add_hash
}

Now let's pull out Data::Alias . This is a module that allows us to create a lexical variable which acts as an alias for another. In particular, we can make a lexical hash variable which acts like an alias for the hash which is pointed to by a hashref.

use Data::Alias;

sub add_hashref_2 {
    my ($href) = @_;                               # faster than add_hash
    alias my %hash = %$href;                       # ... magic happens ...
    return $hash{foo} + $hash{bar} + $hash{baz};   # faster than add_hashref
}

Or better still:

use Data::Alias;

sub add_hashref_3 {
    alias my %hash = %{ $_[0] };
    return $hash{foo} + $hash{bar} + $hash{baz};
}

... which avoids the initial list assignment.

I stress that this is micro -optimization. There are usually far better ways to speed up your code - memoization, radical algorithm changes, rewriting selected hot code paths in XS, etc. But there are some (very limited) occasions when this sort of magic can help.

Answer 2

Your benchmark is faulty.

Your hashref examples not only use a hash, but also create it for each iteration. The hash examples are optimized to always reuse the same hash.

If you amend your second benchmark to force the simple hash version to always create a new hash, the hashref version becomes faster:

cmpthese(10_000_000, {
    hash => sub {
        my %hash;
        $hash{fname}="first name";
        $hash{mname}="middle name";
        $hash{lname}="last name";
        return \%hash;          
    },
    hashref => sub {
        my $hahref;
        $hahref->{fname}="first name"; 
        $hahref->{mname}="middle name";
        $hahref->{lname}="last name"; 
        return $hahref;         
    },
} );

But the real point here is stop trying to microoptimize; write your code the way that makes sense, and only when there proves to be a problem look narrowly at the actually ill-performing code for optimization.

Answer 3

Of course accessing a hash element through a reference will be slower than accessing a hash element directly. Extra work requires extra time.

But how much longer does it take? According to your tests,

( 1 / (5045409/s) - 1/(6045949/s) ) / 3 derefs
= 0.000,000,011 s/deref
= 11 ns/deref

This isn't what you should be worrying about!

if my benchmark is correct and the hash refs are so slow

Your benchmark doesn't show them being slow.

why most modules like DBI use hash refs to return results.

As opposed to what? The only thing a sub can return is a list of scalars. It can't return a hash. fetch_hashref could return a list of key-value pairs from which you could build a hash, but that would be far slower than using a reference if it had already built the hash in the sub.

Answer 4

As I understand it (which could likely be misleading), the biggest advantage of returning a reference vs the actual data structure is in the assignment outside of the subroutine -- not the performance of accessing the structure. Returning a reference will not copy the data in memory on the assignment.

I would expect the second example is probably slower.

my $data = getData();

sub getData {
    return { a => '1' };
}

vs

my %data = getData();

sub getData {
    return my %hash = ( a => '1' );
}