in reply to Re: "exists $hash{key}" is slower than "$hash{key}"
in thread "exists $hash{key}" is slower than "$hash{key}"

If you want to benchmark code using lexical variables, but need to ameliorate the overhead of calling a sub, usually the easiest way is to wrap the code you're benchmarking in a loop that gets executed thousands of times...

#!/usr/bin/perl
use warnings;
use strict;
use Benchmark qw{ cmpthese };

my %h;
@h{1001 .. 2000} = (1) x 1000;
my ($e, $v) = (0) x 2;

cmpthese(-1, {
    exist => sub { for (0..999_999) {   ++$e if exists $h{1001}   } },
    value => sub { for (0..999_999) {   ++$v if $h{1001}          } },
});

__DATA__
        Rate value exist
value 18.3/s    --   -5%
exist 19.3/s    5%    --

[download]
toby döt ink

Replies are listed 'Best First'.
Re^3: "exists $hash{key}" is slower than "$hash{key}"
by swl (Prior) on Jan 06, 2020 at 23:56 UTC

    Thanks for this. The interesting thing is that if I stringify the code to avoid the sub call then I can replicate the ordering from my original post.

    I added a false value to get a sense of the cost of the increment operation. value_true is value from your version, and is obviously faster as it does less work.

    use warnings;
use strict;
use Benchmark qw{ cmpthese };

my %h;
@h{1001 .. 2000} = (1) x 1000;
my ($e, $vt, $vf) = (0) x 3;
$h{1002} = 0;

cmpthese(-2, {
    exist => sub { for (0..999_999) {   ++$e if exists $h{1001}   } },
    exist_str   => 'for (0..999_999) {   ++$e if exists $h{1001}  }',
    value_true  => sub { for (0..999_999) {   ++$vt if $h{1001}   } },
    value_str   => 'for (0..999_999) {   ++$vt if $h{1001}   }',
    value_false => sub { for (0..999_999) {   ++$vf if $h{1002}   } },
});

__DATA__
              Rate       exist  value_true   exist_str   value_str val
+ue_false
exist       16.1/s          --         -9%        -23%        -26%    
+    -27%
value_true  17.7/s         10%          --        -15%        -18%    
+    -20%
exist_str   20.9/s         29%         18%          --         -4%    
+     -6%
value_str   21.7/s         34%         22%          4%          --    
+     -2%
value_false 22.1/s         37%         25%          6%          2%    
+      --

    [download]
[reply]
[d/l]
[select]
      > if I stringify the code to avoid the sub call then I can replicate the ordering from my original post.

      I'm not sure if you got the point, that accessing an outer lexical variable inside a string is not possible.

      Did you?

      The Benchmark module is eventually running the code's text thru eval , but inside it's own scope.

      The my ($e, $vt, $vf) = (0) x 3; are not accessible from there.

      Cheers Rolf
      (addicted to the Perl Programming Language :)
      Wikisyntax for the Monastery FootballPerl is like chess, only without the dice

[reply]
[d/l]
        > The Benchmark module is eventually running the code's text thru eval , but inside it's own scope.

        Not only that, it also turns off strict, so Perl doesn't tell you the hash you're trying to access doesn't exist. 

        sub _doeval { no strict;  eval shift }

        [download]

        map{substr$_->[0],$_->[1]||0,1}[\*||{},3],[[]],[ref qr-1,-,-1],[{}],[sub{}^*ARGV,3]
[reply]
[d/l]
[select]

        The point of the exercise is not to access lexical variables. They are used only so something happens in case that code will otherwise be optimised away (I don't know the internals well enough to be sure). I should have been clearer about this in my original post.

[reply]

In Section Meditations