I expect that cmp in general is a far slower operation than <=>. The latter only takes one CPU instruction (plus the overhead of the interpreter), the former is a slow library call for many strings — especially if the strings you compare are identical, because now all characters in the strings have to be examined.

And I think what you found is that the callback overhead for sort is still faster than the speed difference between these two ops.

Enough blah blah. I've added them to your benchmark code, so it now looks like:

cmpthese(
    $count,
    {
      f_owtdi   => sub { @rfl = sort { $a - $b }   @nfl },
      i_owtdi   => sub { @rin = sort { $a - $b }   @nin },
      f_sship   => sub { @rfl = sort { $a <=> $b } @nfl },
      i_sship   => sub { @rin = sort { $a <=> $b } @nin },
      f_alpha   => sub { @sfl = sort               @afl },
      i_alpha   => sub { @sin = sort               @ain },
      f_cmp     => sub { @sfl = sort { $a cmp $b } @afl },
      i_cmp     => sub { @sin = sort { $a cmp $b } @ain },
    });
[download]

I'll update with the results in a moment. This benchmark takes many minutes to run, and I don't want to skew the results by doing heavy stuff with my humble PC.

Update: I'm back. Here are the results:

Benchmark: timing 300 iterations of f_alpha, f_cmp, f_owtdi, f_sship, 
+i_alpha, i_cmp, i_owtdi, i_sship...
   f_alpha: 26 wallclock secs (25.92 usr +  0.00 sys = 25.92 CPU) @ 11
+.57/s (n=300)
     f_cmp: 26 wallclock secs (25.87 usr +  0.00 sys = 25.87 CPU) @ 11
+.60/s (n=300)
   f_owtdi: 37 wallclock secs (36.58 usr +  0.00 sys = 36.58 CPU) @  8
+.20/s (n=300)
   f_sship: 17 wallclock secs (16.92 usr +  0.00 sys = 16.92 CPU) @ 17
+.73/s (n=300)
   i_alpha: 21 wallclock secs (20.76 usr +  0.00 sys = 20.76 CPU) @ 14
+.45/s (n=300)
     i_cmp: 20 wallclock secs (20.82 usr +  0.00 sys = 20.82 CPU) @ 14
+.41/s (n=300)
   i_owtdi: 35 wallclock secs (35.53 usr +  0.00 sys = 35.53 CPU) @  8
+.44/s (n=300)
   i_sship: 16 wallclock secs (15.87 usr +  0.00 sys = 15.87 CPU) @ 18
+.90/s (n=300)
          Rate f_owtdi i_owtdi f_alpha   f_cmp   i_cmp i_alpha f_sship
+ i_sship
f_owtdi 8.20/s      --     -3%    -29%    -29%    -43%    -43%    -54%
+    -57%
i_owtdi 8.44/s      3%      --    -27%    -27%    -41%    -42%    -52%
+    -55%
f_alpha 11.6/s     41%     37%      --     -0%    -20%    -20%    -35%
+    -39%
f_cmp   11.6/s     41%     37%      0%      --    -20%    -20%    -35%
+    -39%
i_cmp   14.4/s     76%     71%     24%     24%      --     -0%    -19%
+    -24%
i_alpha 14.5/s     76%     71%     25%     25%      0%      --    -18%
+    -24%
f_sship 17.7/s    116%    110%     53%     53%     23%     23%      --
+     -6%
i_sship 18.9/s    130%    124%     63%     63%     31%     31%      7%
+      --
[download]

Just to make sure, I've also swapped $a and $b in my callback sub. It doesn't make a difference.

Conclusion: the speed gain you get by using numerical sort, is entirely due to the speed difference between the ops <=> and cmp.

Interesting:

$ perl -MO=Deparse,x7 -e'sort { $a cmp $b } @x'
sort @x;
-e syntax OK

$ perl -MO=Deparse,x7 -e'sort { $b cmp $a } @x'
sort @x;
-e syntax OK

$ perl -MO=Deparse,x7 -e'sort { $a <=> $b } @x'
sort @x;
-e syntax OK

$ perl -MO=Deparse,x7 -e'sort { $b <=> $a } @x'
sort @x;
-e syntax OK
[download]

So far it looks as though B::Deparse is broken.

$ perl -MO=Deparse,x7 -e'sort { $a->[0] cmp $b->[0] } @x'
sort {$$a[0] cmp $$b[0];} @x;
-e syntax OK
[download]

Obviously, it is not. Looks rather like Perl has builtins for all the common cases, then.

Makeshifts last the longest.

That's very interesting. I had noticed the same thing. Your conclusion might very well be correct, and I hadn't even thought of that possibility.

Could the next be a special common case, too?

perl -MO=Deparse,x7 -e'sort { $b cmp $a } @x'
sort @x;
-e syntax OK
[download]

Well well well, it looks like it. It would explain why there appears to be no overhead for the callback. It can also explain the huge speed difference between "<=>" and "-": only the latter actually uses the callback. Otherwise, it would make no sense: "-" is a very fast operator, and checking the sign of the result should be just as fast. So it must be the overhead of the callback.

Nevertheless, B::Deparse is broken, because the code it produces is obviously not equivalent to the original source code.

perldoc perldelta, for 5.6.1 says the following about sort:

Simple sort() using { $a <=> $b } and the like are optimized

Many common sort() operations using a simple inlined block are now optimized for faster performance.

Mind you, I was under the impression that this optimisation occurred earlier, sometime back around the 5.004 to 5.005 timeframe. I'll have to go and look on some of my older machines.
print@_{sort keys %_},$/if%_=split//,'= & *a?b:e\f/h^h!j+n,o@o;r$s-t%t#u'

Small note which makes no difference to the deparsed syntax is that sort() used in a void context is a no-op (sp?). So all those sort()s could be deparsed down to

$ perl -MO=Deparse,x7 -e'sort { $b <=> $a } @x'
-e syntax OK
[download]

_________
broquaint

My memory of this issue was that the unmodified sort was optimized in older versions of perl, but that recent editions had optimized all four of the common sorts (numeric and standard, forward and backwards). Fortunately (in some sense) I'm equipped to test this hypothesis, having some older installs to work with. I used bart's benchmarking code, for completeness.

It would seem, if I'm reading this right, that the optimization of the basic sort in older versions is just barely enough to make it faster than numeric sort: now that the numeric sort is optimized as well, its inherent speed advantage shows. In 5.6.1, all of the sorts are faster, but the spaceship and cmp sorts improve by much more than the others, because the callback overhead referred to elswhere in this thread is removed.