There are tons of reasons to use references, but if you want to see the speed advantages of them, bench something like this:

#!/usr/bin/perl -w

use Benchmark;

my @array;
for (0..1000) {
  $array[$_] = rand(1000);
}

timethese(200, {
         'ref'       => sub {
           my @unsorted = @array;
           my $return_ref = sort_array_ref(\@unsorted);
         },
         'old skool' => sub {
           my @unsorted = @array;
           my @return_array = sort_array(@unsorted);
         },
        });

sub sort_array_ref {
  my $array_ref = shift;
  my @sorted_array = sort @{$array_ref};
  return \@sorted_array;
}

sub sort_array {
  my @array = @_;
  my @sorted_array = sort @array;
  return @sorted_array;
}

__END__
Benchmark: timing 200 iterations of old skool, ref...
 old skool:  6 wallclock secs ( 5.81 usr +  0.01 sys =  5.82 CPU) @ 34
+.36/s (n=200)
       ref:  6 wallclock secs ( 5.07 usr +  0.01 sys =  5.08 CPU) @ 39
+.37/s (n=200)
[download]

The big performance win from references comes from being able to pass them in and out of subroutines more efficiently. This benchmark illustrates the benefit more clearly:

use strict;
use Benchmark;

my @x = (0..100_000);

sub pass_by_value(@)      { my $x; foreach (@_) { $x += $_ } return $x
+ }
sub pass_by_reference(\@) { my $x; foreach (@$_) { $x += $_ } return $
+x }

timethese(500, {
        'Pass by Ref' =>        sub { pass_by_reference(@x) },
        'Pass by Value' =>      sub { pass_by_value(@x) }
});

sub return_by_value(@)      { return @x };
sub return_by_reference(\@) { return \@x };

timethese(500, {
        'Return by Ref' =>      sub { return_by_reference(@x) },
        'Return by Value' =>    sub { return_by_value(@x) }
});
[download]

Benchmark: timing 500 iterations of Pass by Ref, Pass by Value...
Pass by Ref:  0 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 CPU)
            (warning: too few iterations for a reliable count)
Pass by Value: 78 wallclock secs (67.48 usr +  0.17 sys = 67.65 CPU) @  7.39/s (n=500)
Benchmark: timing 500 iterations of Return by Ref, Return by Value...
Return by Ref:  0 wallclock secs ( 0.00 usr +  0.00 sys =  0.00 CPU)
            (warning: too few iterations for a reliable count)
Return by Value: 16 wallclock secs (14.19 usr +  0.03 sys = 14.22 CPU) @ 35.16/s (n=500)

So, passing references is where I'm going to experience the most performance gains from using refs. Makes sense. Hindsight, my benchmark was highly flawed in what it attempted to quantify. However, the real crux of my post has been, for the most part, left unanswered... where (else) are you likely to note great gains from using references. Where do you not want to use references?

-fp

Any time you derefernce to get to a value pointed to by a reference, it's called a layer of indirection. Every layer of indirection adds some overhead, so if you are acccessing data deep inside a complex data structure, it adds up. Normally this is negligable, but if you are doing so inside loops you can gain more speed by removing as many layers of indirecion as possible.
Take the following code sample. The structure '$data' is two levels deep, and the subs 'foo' and 'bar' both loop thru and access all the data at the deepest level. 'foo' uses a naive aproach of multiple layers of indirection at the deepest level 'my $val = $data->{$key1}->{$key2}', while 'bar' reduces the indirection by assigning the inner data struct to a variable 'my $data2 = $data->{$key1}' and looping over it, accessing that data with 'my $val = $data2->{$key2}'.

results:



Benchmark: timing 100000 iterations of multiple_indirection, reduced_indirection...
multiple_indirection: 29 wallclock secs (28.08 usr +  0.00 sys = 28.08 CPU) @ 3561.25/s (n=100000)
reduced_indirection: 25 wallclock secs (24.19 usr +  0.00 sys = 24.19 CPU) @ 4133.94/s (n=100000)
                       Rate multiple_indirection  reduced_indirection
multiple_indirection 3561/s                   --                 -14%
reduced_indirection  4134/s                  16%                   --


code:


#!/usr/bin/perl
                        
my %innerdata;
@innerdata{a..z} = a..z; 
 
my $data = {
        foo => {
                %innerdata
        },
        bar => {
                %innerdata
        }
};


sub foo {
        my $data = $_[0];
        for $key1 (keys %$data) {
                for $key2 (keys %{$data->{$key1}}) {
                        my $val = $data->{$key1}->{$key2}; 
                        # process $val;
                        # print $val;
                }
        }
}

         
sub bar {
        my $data = $_[0];
        for $key1 (keys %$data) {
                my $data2 = $data->{$key1};
                for $key2 (keys %$data2) {
                        my $val = $data2->{$key2};
                        # process $val;
                        # print $val;
                }
        }
} 

use Benchmark qw(cmpthese);

cmpthese(
        100000,
        {
                multiple_indirection => sub { foo($data) },
                reduced_indirection => sub { bar($data) },
        }
)
[download]

-- O thievish Night, Why should'st thou, but for some felonious end, In thy dark lantern thus close up the stars? --Milton

In order to test, I created a simple sort subroutine inside the Benchmark::timeit call. I've bumped the $count up to 2000 to really get some decent feedback.

I would tend to multiply the value of $count by 50 to a 100 or more. 3 seconds is barely enough time to compare anything. 0.39 seconds difference in CPU time is mere noise.

Remember that a difference of 5 to 10 percent in benchmark performance can also be considered noise. Hence you would want to see 30 seconds vs. 35 seconds (for example) in order to conclude a real (although minor) difference. 30 seconds vs. 75 seconds... now you're starting to talk about something interesting.