The problem is that you are including the time taken to construct the original (anonymous) array.

Try this and see how you get on (the timings shown are AS 5.10.1 under Vista 64-bit):

#!/user/bin/perl
use strict;
use warnings;
use Benchmark qw[ cmpthese ];

sub sum_copy {
    my @numbers = @_;
    my $sum = 0;
    foreach my $num (@numbers){ $sum += $num }
    $sum;
}

sub sum_ref {
    my ($numbers_ref) = @_;
    my $sum = 0;
    foreach my $num (@$numbers_ref){ $sum += $num };
    $sum;
}

our $N //= 1e6;

my @numbers = 1 .. $N;

cmpthese -3, {
    copy => sub{ my $sum = sum_copy( @numbers ); },
    ref  => sub{ my $sum = sum_ref( \@numbers ); },
};

__END__
C:\test>junk28 -N=1e4
       Rate copy  ref
copy 3.92/s   -- -59%
ref  9.67/s 146%   --

C:\test>junk28 -N=1e5
       Rate copy  ref
copy 3.95/s   -- -59%
ref  9.62/s 144%   --

C:\test>junk28 -N=1e6
       Rate copy  ref
copy 3.92/s   -- -59%
ref  9.66/s 146%   --
[download]

This is consistent with what linuxer was saying, too. This helps me a lot and I like your approach, too.

Thanks so much, again, for helping me to restore my sense of order in the world. My results were puzzling to me and left with a bit of virtigo.

My quick look' was *too* quick and, as I noted in my response to linuxer, I forgot one of the lessons that our Benchmarking exist for a reason: they make it easy (easier) to do the job right.

Again, many thanks BrowseUk.

ack Albuquerque, NM

You are measuring the time for creating the array reference. Don't do: print sum([1..100_000]); Do something like this:

#! /usr/bin/perl
# vim:ts=4 sw=4 sts=4 et nu fdc=3:
use strict;
use warnings;
use Benchmark qw( cmpthese );



#> sub routines
#> -------------------------------------------------------------------
+---------

sub sum_list {
    my @numbers = @_;

    my $sum = 0;
    for my $num ( @numbers ) {
        $sum += $num;
    } 

    return $sum;
}

sub sum_by_ref {
    my ( $numbers_ref ) = @_;

    my $sum = 0;
    for my $num ( @$numbers_ref ) {
        $sum += $num;
    } 

    return $sum;
}

#> main script
#> -------------------------------------------------------------------
+---------

my @numbers = 1 .. 1_000_000;
cmpthese( -1, {
    'sum_list'   => sub { sum_list(@numbers);    },    
    'sum_by_ref' => sub { sum_by_ref(\@numbers); },    
});


__END__
[download]

             Rate   sum_list sum_by_ref
sum_list   4.42/s         --       -45%
sum_by_ref 8.00/s        81%         --
[download]

I hope my point got clear ;o)

Addendum: Tested with creating list and reference directly within function call:

cmpthese( -1, {
    'sum_list'   => sub { sum_list(1..1_000_000);     },    
    'sum_by_ref' => sub { sum_by_ref([1..1_000_000]); },    
});

Result:
             Rate   sum_list sum_by_ref
sum_list   4.13/s         --        -9%
sum_by_ref 4.55/s        10%         --
[download]

Thanks, linuxer.

I was trying to do it 'quick n dirty' and obviously did it *too* 'quick n dirty' without paying attention to what I was really doing.

Your results make me feel more confident that I see what is going on and tought me (or re-tought me) a lesson that we talk about periodically in the Monestary: benchmarking is good...but do it right. The tools exist for a reason: to make it easy (or at least easier) to 'do it right'.

I think I need to make a trip to the confessional.

Again, thanks linuxer.

ack Albuquerque, NM

  sub sum {
     my ($numbers_ref) = @_;
     my $sum = 0;
     foreach my $i (0 .. $#{ $numbers_ref }) {
       $sum += $numbers_ref->[$i];
     }
     return $sum;
  }
[download]

Good question...I don't know the answer. The authors apparently didn't think that there is copying going on in the dereferencing since that was essentially the core thesis that they were presenting in that sub-section. I am (or was) assuming that they're pretty tuned in to how Perl's innards work. But then again it wouldn't be the first time that misconceptions even on renouwned authors' expertise were revealed.

In fact that is the source of my commentary and curiosity...is something going on that the authors didn't quite get right?

I *do* like you're thinking, though. My only concern would be its generality in the sense that if the array that $numbers_ref refers to contains numbers other than a simple 0 to N then sum() would not work correctly.

Thank you so much for your ideas and comments. I really appreciate them and you have given me some good ideas.

ack Albuquerque, NM

The difference is the amount of memory allocated and the way that memory is structured.

When passing a list of integers, they are just pushed onto a stack as a series of pointers to small (probably SvIVs), discrete chunks of memory.

When passing a reference to an array, that array has to be constructed first. And an array consists of single, contiguous lump of ramp containing pointers to SVs that contain pointers to the SvIVs. For large arrays, allocating that large contiguous chunk of memory will mean a call out to the OS for a new virtual allocation. And that costs a lot relative to (re)allocating small chunks from the existing memory pool. It then has to allocate the memory for the individual elements and write their pointers to the contiguous chunk, much as it does when pushing the list onto a stack. So the extra step is all cost.

The savings of passing a reference to an array comes when that array already exists. Then just a pointer is pushed rather than pointers to all the contained elements.

Note: My description may not be completely accurate, see PerlGuts Illustrated for the real details.

For the difference in numbers::

sub x{}; 
cmpthese -1,{ 
    a=>q[ x( 1..1e6 ) ], 
    b=>q[x( [1..1e6] ) ] 
};;
    Rate    b    a
b 10.5/s   -- -56%
a 23.8/s 126%   --

@a = 1 .. 1e6;;
cmpthese -1,{ 
    a=>q[ x( @a ) ], 
    b=>q[x( \@a ) ] 
};;
       Rate         a         b
a    24.1/s        --     -100%
b 2903218/s 12025922%        --
[download]

In the first case, the 44% penalty of b is the time taken to allocate that big, contiguous chunk.

In the latter, b's huge advantage is pushing 1 reference .v. pushing 1 million references.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy