Of course it's probably going to be more efficient to get the sorting order to reverse than to physically reverse the sorted list after the sort.

for ( sort { $b cmp $a } @keys ) { print "$_\n"; }
[download]

Update: Oooh, that's good to know. Never mind me then.

reverse sort is optimized to do the reversing in sort itself, so any difference in speed should be very minor.

Update: Corroboration:

>perl -MO=Concise -e"@b = sort @a"
...
7           <@> sort lK ->8
...

>perl -MO=Concise -e"@b = reverse sort @a"
...
7              <@> sort lK/REV ->8
...
[download]

Update: It turns out that sort simply reverses the array at the end. But because it does so in-place without creating any stack frame, it's faster than reverse.

if (PL_op->op_private & OPpSORT_REVERSE) {
    SV **p = sorting_av ? AvARRAY(av) : ORIGMARK+1;
    SV **q = p+max-1;
    while (p < q) {
        SV *tmp = *p;
        *p++ = *q;
        *q-- = tmp;
    }
}
[download]

Note that there is a difference between reverse sort LIST and sort { $b cmp $a } LIST; both are optimized, but the latter is stable (leaves elements in their original order) in the case of distinct elements with the same string value (overloaded, or dual valued), while the former is, err, reversed. Note which elements have a cached numeric value of 0 (and so don't warn in numeric context) here:

$ perl
use strict;
use warnings;
my @blanks = ("","");
{ no warnings; $blanks[0]+0 }
my @stable = sort { $b cmp $a } @blanks;
my @reversed = reverse sort @blanks;
warn '$stable[0]'."\n";
1 if $stable[0]+0;
warn '$stable[1]'."\n";
1 if $stable[1]+0;
warn '$reversed[0]'."\n";
1 if $reversed[0]+0;
warn '$reversed[1]'."\n";
1 if $reversed[1]+0;
__END__
$stable[0]
$stable[1]
Argument "" isn't numeric in addition (+) at - line 10.
$reversed[0]
Argument "" isn't numeric in addition (+) at - line 12.
$reversed[1]
[download]

Sort comparisons of { $a <=> $b } and { $b <=> $a } (with or without reverse) are also optimized.