in reply to Why is split faster than anonymous arrays?

Since tye didn't say anything about it in his post, I'd like to point out that you might wish to look at his use of Benchmark. Honestly, if you are going to do 100000 of something or so, Time::HiRes doesn't buy you much in accuracy.

If you are going to start timing stuff on a regular basis use Benchmark and enjoy the benefits of others hard labor. Since I love these sorts of comparisons, I keep a "testit" file around that looks like this: 

#!/usr/bin/perl -w
use strict;
use Benchmark qw(cmpthese); #cmpthese gives a nice comparison table
use vars qw($s @a $h); # I so that data is visible in evals/subs for s
+ure
# $s = shift;                    # test scalar (ARGV)
# @a = <DATA>;                   # test array
# %h = map { split/=>/ } <DATA>  # test hash

cmpthese ( -10,      #ten seconds rather than X number of loops
  {
    'one' => '',     # eval string style
    'two' => sub {}, # sub ref style
  });
__DATA__

[download]

With the above I can cut-n-paste in code from various places and give it a whirl in no-time. I do recommend that you stick with all sub references or all evals tho, just to keep your sanity.

--
$you = new YOU;
honk() if $you->love(perl)

Replies are listed 'Best First'.
Re: Re: Why is split faster than anonymous arrays?
by rrwo (Friar) on Feb 12, 2001 at 03:51 UTC

    (Somehow my code was cut off...)

    The issue isn't how to benchmark it so much as in "real world testing" using array references seems to be over 10% slower than using split in Perl 5.6 using ActiveState's Perl for Windows.

    This does not make sense to me. Wouldn't it be more work to split a string than to dereference an array?

[reply]
[d/l]
      From what I see of the code, in one you are moving a string in and splitting and returning a list; and in the other you are dereferencing an array ref and making a new list from that array's elements.

      Breaking it down further, I'd say what you are really benchmarking is the speed difference between creating a new set of scalars and upping the refcount on an existing set of scalars.

      Both move a single scalar, both create and return a list, but one creates new scalars and another must run an array down and return all it's guts after changing each one. Running the benchmark below, I get split losing just barely on linux but the difference varied from 1-5% so I'd say that they are basically equivalent Benchmark wise. I'd say the difference you see is either a poorer split implementation or a variation in how the OS's deal with memory allocation and paging. And, I'd stop worrying about it and start coding the way you like. 

      #!/usr/bin/perl -w
use strict;
use Benchmark qw(cmpthese);
use vars qw($d $e @t);
$d = <DATA>;
my @e = split " ", $d;
$e= \@e;

sub sss {
        my $q=shift;
        return (split m/ /, $q)
}

sub aaa {my $q=shift; return @$q}

print $d,$/,sss($d),$/,aaa($e),$/;

cmpthese ( -10,
  {
    split=> '@t = sss($d)',
    arref=> '@t = aaa($e)',
  });
__DATA__
a b c d e f g h i j k l m n o p q r s t u v w x y z

      [download]

      --
      $you = new YOU;
      honk() if $you->love(perl)

[reply]
[d/l]

In Section Seekers of Perl Wisdom