Ok, I took the bait and my faith in the general slowness of threading remains intact. Here's my results:

  $ perl thread.pl -N=100
  Time taken w/ threads: 0.0077 seconds
  Time taken w/ forks: 0.0021 seconds
[download]

And here's my code:

#! perl -slw
use strict;
use threads;
use Time::HiRes qw[ time ];
use Data::Dump qw[ dump ];
use Storable qw[ store_fd fd_retrieve ];

our $N ||= 10;

sub stuff {
    my %hash = (ARGS => \@_,
                A    => [1 .. 10],
                B    => {'a' .. 'z'},
                C    => 'Just a big scalar' x 100,);
    return \%hash;
}

my $complexData;
{
    my $start = time;
    for (1 .. $N) {
        ## "fork" the subroutine
        my ($thread) = async \&stuff, 1, 2.3, 'four';

        ## Do other stuff
        sleep 1;

        ## Get the complex results
        $complexData = $thread->join;
    }
    printf "Time taken w/ threads: %.4f seconds\n", (time() - $start) 
+/ $N - 1;
}

my $complexData2;
{
    my $start = time;
    pipe(READ, WRITE);
    for (1 .. $N) {
        my $pid = fork;
        if (!$pid) {
            # in the kid - do stuff() and send it back to parent
            store_fd(stuff(1, 2.3, 'four'), \*WRITE);
            exit;
        }

        ## Do other stuff
        sleep 1;

        ## Get the complex results
        $complexData2 = fd_retrieve(\*READ);
        waitpid($pid,0);
    }
    printf "Time taken w/ forks: %.4f seconds\n", (time() - $start) / 
+$N - 1;
}

# data should match
if (dump($complexData) ne dump($complexData2)) {
    warn "Data did not match!";
}
[download]

As I was coding it I realized it's kind of a bizarre benchmark since it's not really testing any concurency. It's only testing how fast a single thread/process can be spawned and send back data. And really there's just no way Perl's threads are going to beat fork() at that test!

One neat thing I learned - I didn't realize you could use use Storable's store_fd() and fd_retrieve() to pass messages like this. I'd previously used nstore() and thaw() with a prefixed length() of the message so the other end would know how much to read. This is so much easier!

-sam

PS: I just noticed you're on Windows (or DOS, I guess)! You don't have a real fork() there, so I guess you're not going to be able to replicate my results. Oh well.