in reply to Re: array pre-allocation trick
in thread array pre-allocation trick

Thanks everyone for the help. I tried the benchmark Abigail-II did on my machine, with a map thrown in for good measure, and got slightly different results -- strangely, the simple push won! 
#!/usr/bin/perl
 
use strict;
use warnings;

use Benchmark qw /cmpthese timethese/;
    
our $size = 100_000;
    
cmpthese timethese (-10 =>  {
    push      =>  'my @arr; push @arr => $_ for 0 .. $::size - 1',
    map       =>  'my @arr; @arr = map {$_} (0 ..  $::size - 1)',
    assign    =>  'my @arr; $arr [$_] =  $_ for 0 .. $::size - 1',
    assignpre =>  'my @arr; $#arr = $::size - 1;
                            $arr [$_] =  $_ for 0 .. $::size - 1', 
    slice     =>  'my @arr; @arr [0 .. $::size - 1] = (0 .. $::size - 
+1)',
    slicepre  =>  'my @arr; $#arr = $::size - 1;
                            @arr [0 .. $::size - 1] = (0 .. $::size - 
+1)',
} => 'none');
__END__

            Rate       map  slicepre     slice assignpre    assign    
+  push
map       7.68/s        --      -34%      -36%      -45%      -47%    
+  -48%
slicepre  11.7/s       52%        --       -3%      -17%      -19%    
+  -21%
slice     12.1/s       57%        3%        --      -14%      -17%    
+  -18%
assignpre 14.1/s       83%       20%       16%        --       -3%    
+   -5%
assign    14.5/s       89%       24%       20%        3%        --    
+   -2%
push      14.7/s       92%       26%       22%        5%        2%    
+    --

[download]
Here is what I was running: 
This is perl, v5.6.1 built for i386-linux
Linux cchan.acsys.com 2.4.8-26mdk #1 Sun Sep 23 17:06:39 CEST 2001 i68
+6 unknown

[download]

Replies are listed 'Best First'.
Re: array pre-allocation trick
by Abigail-II (Bishop) on Nov 01, 2002 at 10:59 UTC
    strangely, the simple push won!
    No need to be so surprised. In both your and my benchmark, the difference between "push", "assign" and "assignpre" is small, less than 10%. Speed rate differences as reported by Benchmark can differ drasticly not only between versions of Perl, but only if the underlaying OS differs, or the compiler used to compile Perl (even different versions of the same compiler!). That is, a benchmark can give different "winners" for the same test if the OS, Perl version or compiler differs.

    Abigail

[reply]
[d/l]
[select]
Re: Re: Re: array pre-allocation trick
by BrowserUk (Patriarch) on Oct 31, 2002 at 16:56 UTC

    The map in your example serves no purpose other than to slow it down. The (0 .. $::size-1) builds a list which is directly assignable to an array.

    By adding the map in there, you are

    1. building a list
    2. breaking the list down to feed it to the map element by element
    3. the reassembling a new (identical) list before assigning it to the array.
    Nah! Your thinking of Simon Templar, originally played by Roger Moore and later by Ian Ogilvy
[reply]
[d/l]
      True the map doesn't do much, but it's a minimal benchmark for Aristotle's suggestion: 
      my @array = map { do_stuff_with($_); $_ } 1 .. 5000;

      [download]
      I've replaced "do_stuff_with($_)" with a no-op. It didn't perform as well as the others, so that leads me to think I shouldn't pursue using map in this case.
[reply]
[d/l]
        That very much depends on your setup. map can be the faster, slower or equal variant. There's too many constraints that play a role - you can't just say "this is faster" based on a minimal benchmark because the characteristics of each looping approach lend themselves to different data structure and control flow designs. If you take a forish approach, using map instead will be awkard - but the same is true in the reverse case.

        Makeshifts last the longest.

[reply]
Short note
by Aristotle (Chancellor) on Oct 31, 2002 at 20:00 UTC
    You have some newlines and +s in your code that suggest you copypasted the automatically linewrapped code from Abigail-II's node. Instead, click on the title of the node, then click the "d/l code" below the text to get at the source as originally formatted.

    Makeshifts last the longest.

[reply]

In Section Seekers of Perl Wisdom