in reply to declaring lexical variables in shortest scope: performance?

At least on my 5.28, the difference is negligible:

use warnings;
use strict;
use Benchmark 'cmpthese';

cmpthese(-2, {
    predecl => sub {
        my $y;
        my $x;
        for $x (1,2,3) { $y+=$x }
    },
    lexical => sub {
        my $y;
        for my $x (1,2,3) { $y+=$x }
    },
});

__END__

             Rate predecl lexical
predecl 9175035/s      --     -1%
lexical 9275893/s      1%      --

[download]
But wakes in me primordial fears

Yes, I know the feeling well. But my philosophy has become: first, code so that it works, avoiding only the really obvious performance mistakes (like scanning an array instead of using a hash and the like). Then, if it's fast enough for your puproses, you're done. But if you want to optimize, remember that optimization is a science: measure the performance, identify the hotspots, benchmark the alternatives, modify the code accordingly, measure the difference in performance, and repeat until the performance becomes good enough for your purposes.

Replies are listed 'Best First'.
Re^2: declaring lexical variables in shortest scope: performance?
by bliako (Abbot) on Mar 31, 2020 at 11:05 UTC

    Thanks for the compare script. Indeed the lexical is a bit faster (probably what tobyink said about internal optimisations) and is confirmed by choroba but when I declare a lexical variable inside the loop for my $x (1,2,3) {my $z=12; $y+=$x } in predecl, it's 50% slower :(

    I keep what you said about optimisation is a science

[reply]
[d/l]
      > it's 50% slower

      Do you mean you added the my $z=12; to both the subroutines and the lexical one became 50% slower? I can't reproduce that behaviour. Adding it to only one of the subs slows it (35% in my case), but then we are comparing apples and oranges.

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

        I meant to say that comparing lexicals only: one with a my $z; inside the loop is so much slower. Even 35% is much

        here is the code:

        use Benchmark 'cmpthese';

cmpthese(-2, {
    predecl => '
        my $y;
        my $x;
        for $x (1..10000) { $y+=$x }
    #print "$y\n";
    ',
    lexical => '
        my $y;
        for my $x (1..10000) { $y+=$x }
    #print "$y\n";
    ',
});

__END__

        [download]
                  Rate predecl lexical
predecl 1836/s      --    -54%
lexical 3996/s    118%      --

        [download]
[reply]
[d/l]
[select]
Re^2: declaring lexical variables in shortest scope: performance?
by Anonymous Monk on Mar 31, 2020 at 11:52 UTC
    Maybe it is negligible but that is Benchmark pitfall, overhead drowns out what you're measuring, in line sub contents as strings not sub calls
[reply]
      overhead drowns out what you're measuring, in line sub contents as strings not sub calls

      Can you show the code that demonstrates this?

[reply]

In Section Seekers of Perl Wisdom