# NAME

Parallel::Benchmark - parallel benchmark module

# SYNOPSIS

   use Parallel::Benchmark;
   sub fib {
       my $n = shift;
       return $n if $n == 0 or $n == 1;
       return fib( $n - 1 ) + fib( $n - 2 );
   }
   my $bm = Parallel::Benchmark->new(
       benchmark => sub {
           my ($self, $id) = @_;
           fib(10);  # code for benchmarking
           return 1; # score
       },
       concurrency => 3,
   );
   my $result = $bm->run;
   # output to STDERR
   #  2012-02-18T21:18:17 [INFO] starting benchmark: concurrency: 3, time: 3
   #  2012-02-18T21:18:21 [INFO] done benchmark: score 42018, elapsed 3.000 sec = 14005.655 / sec
   # $result hashref
   # {
   #   'elapsed' => '3.000074',
   #   'score'   => 42018,
   # }

# DESCRIPTION

Parallel::Benchmark is parallel benchmark module.

# METHODS

- __new__(%args)

   create Parallel::Benchmark instance.

       %args:
         benchmark:   CodeRef to benchmark.
         setup:       CodeRef run on child process before benchmark.
         teardown:    CodeRef run on child process after benchmark.
         time:        Int     benchmark running time. default=3
         concurrency: Int     num of child processes. default=1
         debug:       Bool    output debug log.       default=0

- __run__()

   run benchmark. returns result hashref.

       {
         'stashes' => {
           '1' => { },   # $self->stash of child id==1
           '2' => { },
           ...
         },
         'score'   => 1886,        # sum of score
         'elapsed' => '3.0022655', # elapsed time (sec)
       };

- __stash__

   HashRef to store some data while processing.

   Child process's stash returns to result on parent process.

       $result = $bm->run;
       $result->{stashes}->{$id}; #= $self->stash on child $id

- __halt__()

   Halt benchmark on child processes. it means normally exit.

       benchmark => sub {
           my ($self, $id) = @_;
           if (COND) {
              $self->halt("benchmark $id finished!");
           }
           ...
       },

# EXAMPLES

## HTTP GET Benchmark

   use LWP::UserAgent;
   my $bm = Parallel::Benchmark->new(
       setup => sub {
           my ($self, $id) = @_;
           $self->stash->{ua} = LWP::UserAgent->new;
       },
       benchmark => sub {
           my ($self, $id) = @_;
           my $res = $self->stash->{ua}->get("http://127.0.0.1/");
           $self->stash->{code}->{ $res->code }++;
           return 1;
       },
       teardown => sub {
           my ($self, $id) = @_;
           delete $self->stash->{ua};
       },
       concurrency => 2,
   );
   my $result = $bm->run();
   # {
       'stashes' => {
         '1' => {
           'code' => {
             '200' => 932,
             '500' => 7
           }
         },
         '2' => {
           'code' => {
             '200' => 935,
             '500' => 12
           }
         }
       },
       'score' => 1886,
       'elapsed' => '3.0022655'
     }

# AUTHOR

FUJIWARA Shunichiro <[email protected]>

# SEE ALSO

Parallel::ForkManager

# LICENSE

This library is free software; you can redistribute it and/or modify
it under the same terms as Perl itself.